View Javadoc

1   /*
2    * Created on 28/12/2004
3    *
4    */
5   package ecar.servlet.relatorio;
6   
7   import java.lang.reflect.InvocationTargetException;
8   import java.util.ArrayList;
9   import java.util.Collections;
10  import java.util.Comparator;
11  import java.util.Date;
12  import java.util.Iterator;
13  import java.util.List;
14  import java.util.Set;
15  
16  import javax.servlet.http.HttpServletRequest;
17  
18  import comum.database.Dao;
19  import comum.util.Data;
20  import comum.util.Pagina;
21  import comum.util.Util;
22  import comum.util.XmlBuilder;
23  
24  import ecar.bean.AtributoEstruturaListagemItens;
25  import ecar.bean.TotalizadorRelatorios;
26  import ecar.dao.ConfiguracaoDao;
27  import ecar.dao.EstruturaDao;
28  import ecar.dao.EstruturaFuncaoDao;
29  import ecar.dao.ExercicioDao;
30  import ecar.dao.FuncaoDao;
31  import ecar.dao.ItemEstrtIndResulDao;
32  import ecar.dao.ItemEstruturaContaOrcamentoDao;
33  import ecar.dao.ItemEstruturaCriterioDao;
34  import ecar.dao.ItemEstruturaDao;
35  import ecar.dao.ItemEstruturaFonteRecursoDao;
36  import ecar.dao.ItemEstruturaPrevisaoDao;
37  import ecar.dao.SituacaoDao;
38  import ecar.exception.ECARException;
39  import ecar.login.SegurancaECAR;
40  import ecar.pojo.ApontamentoApt;
41  import ecar.pojo.AtributoLivre;
42  import ecar.pojo.ConfiguracaoCfg;
43  import ecar.pojo.CriterioCri;
44  import ecar.pojo.EfIettFonteTotEfieft;
45  import ecar.pojo.EfItemEstContaEfiec;
46  import ecar.pojo.EfItemEstPrevisaoEfiep;
47  import ecar.pojo.EstruturaEtt;
48  import ecar.pojo.EstruturaFuncaoEttf;
49  import ecar.pojo.EstruturaFuncaoEttfPK;
50  import ecar.pojo.ExercicioExe;
51  import ecar.pojo.FuncaoFun;
52  import ecar.pojo.ItemEstrUplCategIettuc;
53  import ecar.pojo.ItemEstrtBenefIettb;
54  import ecar.pojo.ItemEstrtIndResulIettr;
55  import ecar.pojo.ItemEstrutAcaoIetta;
56  import ecar.pojo.ItemEstrutCriterioIettc;
57  import ecar.pojo.ItemEstrutEntidadeIette;
58  import ecar.pojo.ItemEstrutFisicoIettf;
59  import ecar.pojo.ItemEstrutLocalIettl;
60  import ecar.pojo.ItemEstrutUploadIettup;
61  import ecar.pojo.ItemEstruturaIett;
62  import ecar.pojo.ItemEstruturaSisAtributoIettSatb;
63  import ecar.pojo.ObjetoEstrutura;
64  import ecar.pojo.OrgaoOrg;
65  import ecar.pojo.PontoCriticoPtc;
66  import ecar.pojo.RecursoRec;
67  import ecar.pojo.SisAtributoSatb;
68  import ecar.pojo.SituacaoSit;
69  import ecar.pojo.UsuarioUsu;
70  import ecar.util.Dominios;
71  
72  /**
73   * @author felipe, aleixo
74   *
75   */
76  public class RelatorioItemEstrutura extends AbstractServletReportXmlXsl {
77  
78      /**
79  	 * 
80  	 */
81  	private static final long serialVersionUID = 2395457474744685932L;
82  	private List itensMarcados;
83  	private String orgaoEscolhido = "";
84  	private SegurancaECAR seguranca = null;
85  	private List idsEstrutura;
86  	private List totalizadores;
87  	private OrgaoOrg orgaoResponsavel;
88  	private boolean imprimirEstrutura;
89  	private String codEttEscolhida; 
90  	private long codIettPai;
91  	private EstruturaEtt estruturaEscolhida;
92  	
93  	/**
94  	 * CONSTANTES
95  	 */
96  	private static final int COMBOBOX = 1;
97  	private static final int CHECKBOX = 2;
98  	private static final int LISTBOX = 3;
99  	private static final int RADIO_BUTTON = 4;
100 	private static final int TEXT = 5;
101 	private static final int IMAGEM = 6;   
102 	private static final int MULTITEXTO = 7;   
103 	private static final int VALIDACAO = 8;
104 	private static final int MULTIPLO = 9;
105 	private static final int TEXTAREA = 10;
106 	 
107 	
108 	/* TODO: Remover esta variável quando terminar o processo do PPA.
109 	 * Isto só será usando durante o processo PPA. Após este processo, essa verificação será retirada. 
110 	 * Este comentário foi feito para facilitar a retirada deste código após o término do processo do PPA. 
111 	 */
112 	private String contextoEcarPPA;
113 
114 	/**
115 	 * Gera XML.<br>
116 	 * 
117 	 * @author N/C
118      * @since N/C
119      * @version N/C
120 	 * @param HttpServletRequest request
121 	 * @return StringBuffer
122 	 * @throws ECARException
123 	 */
124 	public StringBuffer getXml(HttpServletRequest request) throws ECARException{
125 
126 		XmlBuilder builder = new XmlBuilder();
127 		itensMarcados = new ArrayList();
128         seguranca = (SegurancaECAR)request.getSession().getAttribute("seguranca");
129         idsEstrutura = new ArrayList();
130         totalizadores = new ArrayList();
131     	orgaoResponsavel = new OrgaoOrg();
132     	
133     	Util.liberarImagem();
134     	
135     	imprimirEstrutura = ("S".equals(Pagina.getParamStr(request, "imprimirEstrutura"))) ? true : false;
136     	codEttEscolhida = Pagina.getParamStr(request, "codEttImprimir");
137     	codIettPai = Pagina.getParamLong(request, "codIettPaiImprimir");
138     	
139     	/* TODO: Remover esta variável quando terminar o processo do PPA.
140     	 * Isto só será usando durante o processo PPA. Após este processo, essa verificação será retirada. 
141     	 * Este comentário foi feito para facilitar a retirada deste código após o término do processo do PPA. 
142     	 */
143     	contextoEcarPPA = Pagina.getParamStr(request, "contextoEcarPPA");
144         
145         ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(request);
146         
147         ItemEstruturaIett item = new ItemEstruturaIett(); 
148         if(!imprimirEstrutura){
149         	item = (ItemEstruturaIett) itemEstruturaDao.buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIett")));
150         }
151         else {
152         	EstruturaDao estruturaDao = new EstruturaDao(null);        	
153         	estruturaEscolhida = (EstruturaEtt) estruturaDao.buscar(EstruturaEtt.class, Long.valueOf(codEttEscolhida)); 
154         }
155 
156         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"
157         ConfiguracaoCfg config = new ConfiguracaoDao(null).getConfiguracao();
158         String titulo = config.getTituloSistema();//Pagina.getParamStr(request, "titulo_sistema");
159         String tituloItens = "";
160         String cabecalho = "";
161         
162         
163     	//Verifica se é para filtrar por Critérios
164     	String criteriosCom = Pagina.getParamStr(request, "criteriosIncluidosCom");
165     	String criteriosSem = Pagina.getParamStr(request, "criteriosIncluidosSem");
166     	String[] criteriosParaFiltrarCom = (!"".equals(criteriosCom.trim())) ? criteriosCom.split("\\|") : new String[] {};
167     	String[] criteriosParaFiltrarSem = (!"".equals(criteriosSem.trim())) ? criteriosSem.split("\\|") : new String[] {};
168 
169     	List listaCriteriosCom = new ArrayList();					
170     	List listaCriteriosSem = new ArrayList();					
171 
172     	for(int i = 0; i < criteriosParaFiltrarCom.length; i++){
173     		listaCriteriosCom.add(criteriosParaFiltrarCom[i]);
174     	}
175         
176     	for(int i = 0; i < criteriosParaFiltrarSem.length; i++){
177     		listaCriteriosSem.add(criteriosParaFiltrarSem[i]);
178     	}
179 
180     	//Pegando as situacoes que foram selecionados como filtro
181     	String situacoes = Pagina.getParamStr(request, "situacoesIncluidas");
182     	String[] situacoesParaFiltrar = (!"".equals(situacoes.trim())) ? situacoes.split("\\|") : new String[] {};
183 
184     	List listaSituacoes = new ArrayList();					
185 
186     	for(int i = 0; i < situacoesParaFiltrar.length; i++){
187     		listaSituacoes.add(situacoesParaFiltrar[i]);
188     	}        
189     	
190     	//Pegando o órgão selecionado
191     	Dao dao = new Dao();
192 		String orgao =  request.getParameter("codOrgaoSelecionado");
193         
194     	if(!"".equals(orgao) && orgao != null){
195     		orgaoResponsavel = (OrgaoOrg) dao.buscar(OrgaoOrg.class, Long.valueOf(orgao));
196     	}
197     	
198     	orgaoEscolhido = (orgaoResponsavel.getCodOrg() != null) ? orgaoResponsavel.getSiglaOrg() : "Todos os Órgãos";
199         
200     	cabecalho = "Relatório ";
201         if("C".equals(Pagina.getParamStr(request, "indTipoRelatorio"))){
202         	cabecalho += "Completo";
203         }
204         else {
205         	if(!"S".equals(contextoEcarPPA))
206         		cabecalho += "Resumido";
207         	else
208         		cabecalho += "do Resumo do PPA";
209         }
210         
211         if(!"S".equals(contextoEcarPPA))
212         	cabecalho += " da Estrutura do " + titulo;
213         
214         if("T".equals(Pagina.getParamStr(request, "todosCheck"))){
215         	tituloItens = "Todos";
216         }
217         else if("M".equals(Pagina.getParamStr(request, "todosCheck"))){
218         	tituloItens = "Monitorados";
219         }
220         else if("N".equals(Pagina.getParamStr(request, "todosCheck"))){
221         	tituloItens = "Não Monitorados";
222         }
223         else {
224         	tituloItens = "Conforme Relação Informada Pelo Usuário";
225         }
226         
227         builder.addNode("relatorio", 
228         		"titulo=\"" + builder.normalize(cabecalho) + "\"" +
229         		" datahora=\"" + datahora + "\"");
230         
231         /* Imprime a capa*/
232         geraXMLCapa(builder, titulo, tituloItens, orgaoEscolhido, listaCriteriosCom, listaCriteriosSem, listaSituacoes);
233 
234         if(!imprimirEstrutura){
235         	itensMarcados.add(item.getCodIett().toString());
236         }
237         
238         String[] itensMarcadosNaPagina = request.getParameterValues("itemFilho");
239         
240         if(itensMarcadosNaPagina != null){
241             for(int i = 0; i < itensMarcadosNaPagina.length; i++){
242             	itensMarcados.add(itensMarcadosNaPagina[i]);
243             }
244         }
245 
246         /* Imprime o relatório do Item Principal */ 
247         geraXMLItem(builder, item, Pagina.getParamStr(request, "indTipoRelatorio"), orgao, listaCriteriosCom, listaCriteriosSem, listaSituacoes);
248             
249         geraXMLTotalizador(builder);
250         
251         builder.closeNode("relatorio");
252         
253         return builder.toStringBuffer();
254     }
255     
256 	/**
257 	 * Gera Capa XML.<br>
258 	 * 
259 	 * @author N/C
260      * @since N/C
261      * @version N/C
262 	 * @param XmlBuilder builder
263 	 * @param String titulo
264 	 * @param String tituloItens
265 	 * @param String orgao
266 	 * @param List listaCriteriosCom
267 	 * @param List listaCriteriosSem
268 	 * @param List listaSituacoes
269 	 * @throws ECARException
270 	 */
271     public void geraXMLCapa(XmlBuilder builder, String titulo, String tituloItens, 
272     		String orgao, List listaCriteriosCom, List listaCriteriosSem, List listaSituacoes) throws ECARException{
273         builder.addNode("capa",
274         		"titulo=\"" + builder.normalize(titulo) + "\"" +
275         		" tituloItens=\"" + builder.normalize(tituloItens) + "\"" +
276         		" orgao=\"" + builder.normalize(orgao) + "\"");
277         
278         SituacaoDao situacaoDao = new SituacaoDao(null);
279         ItemEstruturaCriterioDao itemCriterioDao = new ItemEstruturaCriterioDao(null);
280         FuncaoDao funcaoDao = new FuncaoDao(null);
281     	FuncaoFun criterioFun = funcaoDao.getFuncao(Long.valueOf("6")); // 6 = Critérios
282     	
283     	if(criterioFun != null && 
284     			(listaCriteriosCom != null && listaCriteriosCom.size() > 0
285     			|| listaCriteriosSem != null && listaCriteriosSem.size() > 0)){
286         	builder.addNode("filtros", "tipo=\"" + builder.normalize(criterioFun.getLabelPadraoFun()) + "\"" +
287         					" estilo=\"CS\""); //CS --> Monta tabela com colunas de Com/Sem
288 	        
289         	if(listaCriteriosCom != null && listaCriteriosCom.size() > 0){
290 	        	Iterator itCriterios = listaCriteriosCom.iterator();
291 		        while(itCriterios.hasNext()){
292 		        	String id = (String) itCriterios.next();
293 		        	CriterioCri criterio = (CriterioCri) itemCriterioDao.buscar(CriterioCri.class, Long.valueOf(id));
294 		        	
295 		        	if(criterio != null){
296 		        		builder.addClosedNode("filtro", " valor=\"" + builder.normalize(criterio.getDescricaoCri()) + "\" tipo=\"C\"");
297 		        	}
298 		        }
299         	}
300         	
301         	if(listaCriteriosSem != null && listaCriteriosSem.size() > 0){
302 	        	Iterator itCriterios = listaCriteriosSem.iterator();
303 		        while(itCriterios.hasNext()){
304 		        	String id = (String) itCriterios.next();
305 		        	CriterioCri criterio = (CriterioCri) itemCriterioDao.buscar(CriterioCri.class, Long.valueOf(id));
306 		        	
307 		        	if(criterio != null){
308 		        		builder.addClosedNode("filtro", " valor=\"" + builder.normalize(criterio.getDescricaoCri()) + "\" tipo=\"S\"");
309 		        	}
310 		        }
311         	}
312 	        
313         	builder.closeNode("filtros");
314     	}
315     	
316     	if(listaSituacoes != null && listaSituacoes.size() > 0){
317         	builder.addNode("filtros", "tipo=\"" + builder.normalize("Situações") + "\"" +
318 			" estilo=\"SI\""); //SI --> Simples, Sem colunas de Com/Sem
319         	
320         	Iterator itSituacoes = listaSituacoes.iterator();
321         	while(itSituacoes.hasNext()){
322         		String id = (String) itSituacoes.next();
323         		SituacaoSit situacao = (SituacaoSit) situacaoDao.buscar(SituacaoSit.class, Long.valueOf(id)); 
324         		if(situacao != null){
325         			builder.addClosedNode("filtro", " valor=\"" + builder.normalize(situacao.getDescricaoSit()) + "\" tipo=\"N\"");
326         		}
327         	}
328         	builder.closeNode("filtros");
329     	}
330         
331         builder.closeNode("capa");
332     }
333 
334     /**
335      * Gera item xml.<br>
336      * 
337      * @author N/C
338      * @since N/C
339      * @version N/C
340      * @param XmlBuilder builder
341      * @param ItemEstruturaIett item
342      * @param String tipoRelatorio
343      * @param String orgao
344      * @param List listaCriteriosCom
345      * @param List listaCriteriosSem
346      * @param List listaSituacoes
347      * @throws ECARException
348      */
349     public void geraXMLItem(XmlBuilder builder, ItemEstruturaIett item, String tipoRelatorio, 
350     		String orgao, List listaCriteriosCom, List listaCriteriosSem, List listaSituacoes) throws ECARException{
351 
352 		/* TODO: Remover esta validação quando terminar o processo do PPA.
353 		 * 
354 		 * "No relatório "Resumo", não exibir itens do nível de subproduto
355 		 * Isto só será usando durante o processo PPA. Após este processo, essa verificação será retirada. 
356 		 * Este comentário foi feito para facilitar a retirada deste código após o término do processo do PPA. 
357 		 */
358 		boolean exibirItem = true;
359 		if("R".equals(tipoRelatorio)){
360 			exibirItem = false;
361 			if(!imprimirEstrutura && item.getNivelIett() != null && item.getNivelIett().intValue() != 5){ //5 = Nível de Subproduto.
362 				exibirItem = true;
363 			}
364 			else if(imprimirEstrutura){
365 				exibirItem = true;
366 			}
367 		}
368 		
369 		if(!"S".equals(contextoEcarPPA))
370 			exibirItem = true;
371 		
372     	if(exibirItem){
373 	    	
374 	    	builder.addNode("item");
375 
376 	    	/*
377 	    	if(!imprimirEstrutura){
378 		        //geraXMLHierarquia(builder, item, tipoRelatorio);
379 		        
380 		        boolean mostrarDados = false;
381 		        
382 		        if("".equals(orgao) || orgao == null){ //Todos
383 		        	mostrarDados = true;
384 		        }
385 		        else if (orgao != null && item.getOrgaoOrgByCodOrgaoResponsavel1Iett() != null && orgao.equals(item.getOrgaoOrgByCodOrgaoResponsavel1Iett().getCodOrg().toString())){
386 		        	mostrarDados = true;
387 		        }
388 		        
389 		        if (!itensMarcados.contains(item.getCodIett().toString())){
390 		        	mostrarDados = false;
391 		        }
392 		        
393 		        if(mostrarDados){
394 		        	
395 		        	this.incrementarTotalizador(item.getEstruturaEtt().getCodEtt(), item.getEstruturaEtt().getNomeEtt());
396 		        	
397 		        	geraXMLDadosBasicos(builder, item, tipoRelatorio);
398 		        
399 		        	if("C".equals(tipoRelatorio)){
400 		        		geraXMLNiveisPlanejamento(builder, item);
401 		        	}
402 		        
403 		        	geraXMLFuncoes(builder, item, tipoRelatorio,false);
404 		        }
405 	    	}*/
406 	       	geraXMLFilhosPorOrgao(builder, item, tipoRelatorio, orgao, listaCriteriosCom, listaCriteriosSem, listaSituacoes);
407 	        builder.closeNode("item");
408     	}
409     }
410     
411 
412     /**
413      * Gera funções xml.<br>
414      * 
415      * @author N/C
416      * @since N/C
417      * @version N/C
418      * @param XmlBuilder builder
419      * @param ItemEstruturaIett item
420      * @param String tipoRelatorio
421      * @param boolean exibirCategoriaSemItemAnexo
422      * @throws ECARException
423      */
424     public void geraXMLFuncoes(XmlBuilder builder, ItemEstruturaIett item, String tipoRelatorio, 
425     		boolean exibirCategoriaSemItemAnexo) throws ECARException{
426         
427     	boolean mostrouIndicadorResultado = false;
428     	boolean mostrouFontesRecursos = false;
429     	boolean mostrouPontosCriticos = false;
430     	boolean mostrouCategorias = false;
431     	
432     	boolean exibirQuantidadesPrevistas = false;
433     	boolean exibirRecursos = false;
434     	boolean exibirApontamentos = false;
435     	boolean exibirItensAnexo = false;
436     	
437     	Set funcoes = item.getEstruturaEtt().getEstruturaFuncaoEttfs();
438         List funcoesParalela = new ArrayList(funcoes);
439     	
440         Iterator itFuncoes = funcoes.iterator();
441         while(itFuncoes.hasNext()){
442             EstruturaFuncaoEttf estruturaFuncao = (EstruturaFuncaoEttf) itFuncoes.next();
443             try{
444                 boolean mostraDados = false;
445                 if("S".equals(estruturaFuncao.getIndListagemImpressaResEttf()) && "R".equals(tipoRelatorio)){
446                     mostraDados = true;
447                 }
448                 if("S".equals(estruturaFuncao.getIndListagemImpressCompEttf()) && "C".equals(tipoRelatorio)){
449                     mostraDados = true;
450                 }
451                 if(mostraDados){
452                     
453 //                	this.getClass().getMethod("geraXML"+ Util.primeiraLetraToUpperCase(estruturaFuncao.getFuncaoFun().getNomeFun()), new Class[]{XmlBuilder.class, ItemEstruturaIett.class, String.class}).invoke(this, new Object[]{builder, item, estruturaFuncao.getLabelEttf()});
454                 	
455                 	String funcao = Util.primeiraLetraToUpperCase(estruturaFuncao.getFuncaoFun().getNomeFun());
456                 	if ("Quantidades_Previstas".equals(funcao)){
457                 		exibirQuantidadesPrevistas = true;
458                 		if (!mostrouIndicadorResultado){
459                 			mostrouIndicadorResultado = true;
460                 			EstruturaFuncaoEttf funcaoPai = this.buscarFuncaoPai(item, Long.valueOf("14")); //Indicadores de Resultado
461 	                		if(funcaoPai != null){
462 	                			this.geraXMLIndicadores_Resultado(builder, item, funcaoPai.getLabelEttf(), exibirQuantidadesPrevistas);
463 	                		}
464                 		}
465                 	}
466                 	else if ("Indicadores_Resultado".equals(funcao)){
467             			if(!mostrouIndicadorResultado){
468             				mostrouIndicadorResultado = true;
469                				exibirQuantidadesPrevistas = this.verificarFuncao("Quantidades_Previstas", funcoesParalela, tipoRelatorio);
470             				this.geraXMLIndicadores_Resultado(builder, item, estruturaFuncao.getLabelEttf(), exibirQuantidadesPrevistas);
471             			}
472             			else {
473             				continue;
474             			}
475             		}
476                 	else if ("Recursos".equals(funcao)){
477                 		exibirRecursos = true;
478                 		if (!mostrouFontesRecursos){
479                 			mostrouFontesRecursos = true;
480                 			EstruturaFuncaoEttf funcaoPai = this.buscarFuncaoPai(item, Long.valueOf("9")); //Fontes de Recursos
481                 			if(funcaoPai != null){
482                 				this.geraXMLFontes_Recursos(builder, item, funcaoPai.getLabelEttf(), exibirRecursos);
483                 			}
484                 		}
485                 	}
486                 	else if ("Fontes_Recursos".equals(funcao)){
487                 		if (!mostrouFontesRecursos){
488                 			mostrouFontesRecursos = true;
489                 			exibirRecursos = this.verificarFuncao("Recursos", funcoesParalela, tipoRelatorio);
490                 			this.geraXMLFontes_Recursos(builder, item, estruturaFuncao.getLabelEttf(), exibirRecursos);
491                 		}
492                 		else {
493                 			continue;
494                 		}
495                 	}
496                 	else if ("Apontamentos".equals(funcao)){
497                 		exibirApontamentos = true;
498                 		if (!mostrouPontosCriticos){
499                 			mostrouPontosCriticos = true;
500                 			EstruturaFuncaoEttf funcaoPai = this.buscarFuncaoPai(item, Long.valueOf("12")); //Pontos Críticos
501                 			if(funcaoPai != null){
502                 				this.geraXMLPontos_Criticos(builder, item, funcaoPai.getLabelEttf(), exibirApontamentos);
503                 			}
504                 		}
505                 	}
506                 	else if ("Pontos_Criticos".equals(funcao)){
507                 		if (!mostrouPontosCriticos){
508                 			mostrouPontosCriticos = true;
509                 			exibirApontamentos = this.verificarFuncao("Apontamentos", funcoesParalela, tipoRelatorio);
510                 			this.geraXMLPontos_Criticos(builder, item, estruturaFuncao.getLabelEttf(), exibirApontamentos);
511                 		}
512                 		else {
513                 			continue;
514                 		}
515                 	}
516                 	else if("Itens_de_Anexo".equals(funcao)){
517                 		exibirItensAnexo = true;
518                 		if (!mostrouCategorias){
519                 			mostrouCategorias = true;
520                 			EstruturaFuncaoEttf funcaoPai = this.buscarFuncaoPai(item, Long.valueOf("2")); //Categorias
521                 			if (funcaoPai != null){
522                 				this.geraXMLCategorias(builder, item, funcaoPai.getLabelEttf(), exibirItensAnexo, exibirCategoriaSemItemAnexo);
523                 			}
524                 		}
525                 	}
526                 	else if ("Categorias".equals(funcao)){
527                 		if (!mostrouCategorias){
528                 			mostrouCategorias = true;
529                 			exibirItensAnexo = this.verificarFuncao("Itens_de_Anexo", funcoesParalela, tipoRelatorio);
530                 			this.geraXMLCategorias(builder, item, estruturaFuncao.getLabelEttf(), exibirItensAnexo, exibirCategoriaSemItemAnexo);
531                 		}
532                 		else {
533                 			continue;
534                 		}
535                 	}
536             		else {
537                 		this.getClass().getMethod("geraXML"+ funcao, new Class[]{XmlBuilder.class, ItemEstruturaIett.class, String.class}).invoke(this, new Object[]{builder, item, estruturaFuncao.getLabelEttf()});
538             		}
539 //                		this.getClass().getMethod("geraXML"+ funcao, new Class[]{XmlBuilder.class, ItemEstruturaIett.class, String.class}).invoke(this, new Object[]{builder, item, estruturaFuncao.getLabelEttf()});
540                 }
541             } catch(InvocationTargetException e){     
542             	this.logger.error(e);
543                 /* se a exceção capturada for uma ECARException deve ser passada para frente, senao deve ser ignorada pois ocorreu 
544                  * uma NoSuchMethodException devido ao sistema ter tentado chamar um método geraXMLxxxx que não foi implementado.
545                  * Como os métodos são chamados por reflexão, todas as exceptions que eles dispararem serão encapsuladas em uma
546                  * InvocationTargetException. Por isso a ECARException é retirada dela e passada para frente.
547                  * Por exemplo, não existe um método geraXMLRecursos, pois os recursos são tratados pelo método que gera relatório
548                  * da fonte de recurso. Porém sempre que cria um relatório o sistema tentará chamar o método geraXMLRecurso se na
549                  * configuração da estrutura estiver informado que "recursos" deve aparecer no relatório ( configuração incorreta,
550                  * pois os recursos apareceram sempre que aprecer Fonte de Recurso)                 
551                  */                    
552 
553                 throw (ECARException) e.getTargetException();
554             } catch (Exception e) {
555                 this.logger.error(e);
556             } 
557             
558         } 
559 
560     }
561     
562     /**
563      * Gera hieraquia xml.<br>
564      * 
565      * @author N/C
566      * @since N/C
567      * @version N/C
568      * @param XmlBuilder builder
569      * @param ItemEstruturaIett item
570      * @param String tipoRelatorio
571      * @throws ECARException
572      */
573     public void geraXMLHierarquia(XmlBuilder builder, ItemEstruturaIett item, String tipoRelatorio) throws ECARException{
574         try{
575             builder.addNode("hierarquia");
576             ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(null);
577     	    List pais = itemEstruturaDao.getAscendentes(item);
578     	    Iterator it = pais.iterator();
579     	    while(it.hasNext()){
580     	        ItemEstruturaIett pai = (ItemEstruturaIett) it.next();
581 				String nomeNivel = pai.getNomeIett();
582 				if(pai.getSiglaIett() != null && !"".equals(pai.getSiglaIett()))
583 					nomeNivel = pai.getSiglaIett() + " - " + nomeNivel;
584 				builder.addClosedNode("nivel", "estrutura=\"" + builder.normalize(pai.getEstruturaEtt().getNomeEtt()) + ":\" nomeNivel=\"" + builder.normalize(nomeNivel) + "\"");
585 				
586 				this.incrementarTotalizador(pai.getEstruturaEtt().getCodEtt(), pai.getEstruturaEtt().getNomeEtt() + ":");
587     	    }
588 //			String nomeNivel = item.getNomeIett();
589 			
590 			/* TODO: Remover esta validação quando terminar o processo do PPA.
591 			 * 
592 			 * Este if é referente ao item 4 do Mantis 5160:
593 			 * "No relatório "Resumo", no nível da ação, Substituir o Nome da ação pelo Nome PPA"
594 			 * Isto só será usando durante o processo PPA. Após este processo, essa verificação será retirada. 
595 			 * Este comentário foi feito para facilitar a retirada deste código após o término do processo do PPA. 
596 			 */
597 			String nomeNivel = "";
598 			boolean buscarNomePPA = false;
599 			if("R".equals(tipoRelatorio)){
600 				if(item.getNivelIett() != null && (item.getNivelIett().intValue() == 3 || item.getNivelIett().intValue() == 4)){ //3 = Nível de Ação, 4 = Nível de Produto
601 					buscarNomePPA = true;
602 				}
603 			}
604 
605 			if(!"S".equals(contextoEcarPPA))
606 				buscarNomePPA = false;
607 			
608 			if(buscarNomePPA)
609 				nomeNivel += builder.normalize(item.getDescricaoR3());
610 			else
611 				nomeNivel += builder.normalize(item.getNomeIett());
612 			
613 			
614 			if(item.getSiglaIett() != null && !"".equals(item.getSiglaIett()))
615 				nomeNivel = item.getSiglaIett() + " - " + nomeNivel;
616 			builder.addClosedNode("nivel", "estrutura=\"" + builder.normalize(item.getEstruturaEtt().getNomeEtt()) + ":\" nomeNivel=\"" + builder.normalize(nomeNivel) + "\"");
617     	    
618 			this.incrementarTotalizador(item.getEstruturaEtt().getCodEtt(), item.getEstruturaEtt().getNomeEtt() + ":");
619 			
620     	    builder.closeNode("hierarquia");
621         } catch(Exception e){
622         	this.logger.error(e);
623             throw new ECARException("Erro na criação do Relatório: Hierarquia de Itens");
624         }
625     }
626 
627     /**
628      * Gera dados basicos xml.<br>
629      * 
630      * @author N/C
631      * @since N/C
632      * @version N/C
633      * @param XmlBuilder builder
634      * @param ItemEstruturaIett item
635      * @param StringtipoRelatorio
636      * @throws ECARException
637      */
638     public void geraXMLDadosBasicos(XmlBuilder builder, ItemEstruturaIett item, String tipoRelatorio) throws ECARException{
639         try{
640             /* DADOS BÁSICOS */
641             List dados = new EstruturaDao(null).getAtributosEstruturaRelatorio(item.getEstruturaEtt(), tipoRelatorio);
642             if(dados.size() > 0){
643                 builder.addNode("dadosBasicos");
644                 Iterator itDados = dados.iterator();
645                 while(itDados.hasNext()){
646                     ObjetoEstrutura estruturaAtributo = (ObjetoEstrutura) itDados.next();
647 
648                     String nomeAtributo = estruturaAtributo.iGetNome();
649                     String valor = "";
650                     
651                     if(estruturaAtributo.iGetGrupoAtributosLivres() != null){
652                     	//Atributo Livre:
653                     	if(item.getItemEstruturaSisAtributoIettSatbs() != null){
654                     		int tam = item.getItemEstruturaSisAtributoIettSatbs().size();
655                     		int pos = 1;
656                 	    	Iterator itAtribLivres = item.getItemEstruturaSisAtributoIettSatbs().iterator();
657                 	    	while(itAtribLivres.hasNext()){
658                 	    		ItemEstruturaSisAtributoIettSatb atributo = (ItemEstruturaSisAtributoIettSatb) itAtribLivres.next();
659                 	    		AtributoLivre atributoLivre = new AtributoLivre();
660                 	    		atributoLivre.setSisAtributoSatb(atributo.getSisAtributoSatb());
661                 	    		atributoLivre.setInformacao(atributo.getInformacaoIettSatb());
662                 	    		
663                 	    		if(!atributoLivre.getSisAtributoSatb().getSisGrupoAtributoSga().equals(estruturaAtributo.iGetGrupoAtributosLivres()))
664                 	    			continue;
665                 	    		
666                 	    		if((atributoLivre.getSisAtributoSatb()
667                 	    				.getSisGrupoAtributoSga()
668                 	    				.getSisTipoExibicGrupoSteg()
669                 	    				.getCodSteg().intValue() != TEXT) && 
670                 	    			(atributoLivre.getSisAtributoSatb()
671                         	    			.getSisGrupoAtributoSga()
672                         	    			.getSisTipoExibicGrupoSteg()
673                         	    			.getCodSteg().intValue() != TEXTAREA)) {
674                 	    		
675 	                	    		String separador = "";
676 	                	    		if(tam > 1 && pos < tam){
677 	                	    			separador = ", ";
678 	                	    		}
679 	                	    		
680 	                	    		if(atributoLivre.getSisAtributoSatb() != null)
681 	                	    			valor += atributoLivre.getSisAtributoSatb().getDescricaoSatb() + separador;
682 	                	    		else
683 	                	    			valor += atributoLivre.getInformacao() + separador;
684 	                	    		
685 	                	    		pos++;
686                 	    		} else {
687                 	    			valor = atributoLivre.getInformacao();
688                 	    		}
689                 	    	}
690                     	}
691              
692                     	valor = valor.trim(); 
693                     }
694                     else {
695                     	if("nivelPlanejamento".equals(estruturaAtributo.iGetNome())){
696                         	if(item.getItemEstruturaNivelIettns() != null){
697                         		int tam = item.getItemEstruturaNivelIettns().size();
698                         		int pos = 1;
699                     	    	Iterator niveis = item.getItemEstruturaNivelIettns().iterator();
700                     	    	while(niveis.hasNext()){
701                     	    		SisAtributoSatb nivel = (SisAtributoSatb) niveis.next();
702                     	    		
703                     	    		String separador = "";
704                     	    		if(tam > 1 && pos < tam){
705                     	    			separador = ", ";
706                     	    		}
707 
708                     	    		valor += nivel.getDescricaoSatb() + separador;
709                     	    		
710                     	    		pos++;
711                     	    	}
712                         	}
713                  
714                         	valor = valor.trim(); 
715                     		
716                     	}
717                     	else {
718                         	valor = estruturaAtributo.iGetValor(item);
719                     	}
720                     	
721                     }
722                     
723                     String tipoAtributo = descobreTipo(nomeAtributo);
724                     
725                     valor = Util.normalizaCaracterMarcador(valor);
726                     
727                     boolean gerarDados = true;
728                     if("S".equals(contextoEcarPPA) && "R".equals(tipoRelatorio) && "".equals(valor))
729                     	gerarDados = false;
730                     
731                     if(gerarDados)
732                     	builder.addClosedNode(tipoAtributo, "label=\"" + builder.normalize(estruturaAtributo.iGetLabel()) + ": \"" + " valor=\"" + builder.normalize(valor) + "\"");
733                 }
734                 builder.closeNode("dadosBasicos");
735             }
736         } catch(Exception e){
737         	this.logger.error(e);
738             throw new ECARException("Erro na criação do relatório: Dados Básicos");               
739         }
740     }
741     
742     /**
743      * Gera niveis de planejamento xml.<br>
744      * 
745      * @author N/C
746      * @since N/C
747      * @version N/C
748      * @param XmlBuilder builder
749      * @param ItemEstruturaIett item
750      * @throws ECARException
751      */
752     public void geraXMLNiveisPlanejamento(XmlBuilder builder, ItemEstruturaIett item) throws ECARException{
753         try{            
754             if(item.getItemEstruturaNivelIettns().size() > 0){
755                 boolean first = true;
756                 Iterator it = item.getItemEstruturaNivelIettns().iterator();        
757                 while(it.hasNext()){
758                     SisAtributoSatb atributo = (SisAtributoSatb) it.next();
759                     if(first){
760                         builder.addNode("niveisPlanejamento");
761                         first = false;
762                     }
763                     builder.addAndCloseNode("nivelPlanejamento", builder.normalize(Pagina.trocaNull(atributo.getDescricaoSatb())));
764                 }        
765                 builder.closeNode("niveisPlanejamento");                    
766             }    
767         } catch(Exception e){
768         	this.logger.error(e);
769             throw new ECARException("Erro na criação do relatório: Níveis do Planejamento");    
770         }        
771     }
772     
773     /**
774      * Gera beneficiarios xml.<br>
775      * 
776      * @author N/C
777      * @since N/C
778      * @version N/C
779      * @param XmlBuilder builder
780      * @param ItemEstruturaIett item
781      * @param String label
782      * @throws ECARException
783      */
784     public void geraXMLBeneficiarios(XmlBuilder builder, ItemEstruturaIett item, String label) throws ECARException{
785         try{
786             if(item.getItemEstrtBenefIettbs().size() > 0){
787                 builder.addNode("beneficiarios", "label=\"" + builder.normalize(label) + "\"");
788                 Iterator it = item.getItemEstrtBenefIettbs().iterator();
789                 while(it.hasNext()){
790                     ItemEstrtBenefIettb beneficiario = (ItemEstrtBenefIettb) it.next();
791                     builder.addClosedNode("beneficiario", "descricao=\"" + builder.normalize(Pagina.trocaNull(beneficiario.getBeneficiarioBnf().getNomeBnf())) +
792                             			"\" quantidade=\"" + builder.normalize(Pagina.trocaNull(beneficiario.getQtdPrevistaIettb())) + "\" observacoes=\"" 
793                             			+ builder.normalize(Pagina.trocaNull(beneficiario.getComentarioIettb())) + "\"");
794                 }        
795                 builder.closeNode("beneficiarios");           
796             }
797         } catch(Exception e){
798         	this.logger.error(e);
799             throw new ECARException("Erro na criação do relatório: " + label);              
800         }
801     }
802     
803     /**
804      * Gera eventos xml.<br>
805      * 
806      * @author N/C
807      * @since N/C
808      * @version N/C
809      * @param XmlBuilder builder
810      * @param ItemEstruturaIett item
811      * @param String label
812      * @throws ECARException
813      */
814     public void geraXMLEventos(XmlBuilder builder, ItemEstruturaIett item, String label) throws ECARException{
815         try{
816             if(item.getItemEstrutAcaoIettas().size() > 0){            
817                 builder.addNode("acoes", "label=\"" + builder.normalize(label) + "\"");
818                 Iterator it = item.getItemEstrutAcaoIettas().iterator();
819                 while(it.hasNext()){
820                     ItemEstrutAcaoIetta acao = (ItemEstrutAcaoIetta) it.next();
821                     
822     				// ignorar registro inativo
823     				if(Dominios.NAO.equals(acao.getIndAtivoIetta())) {
824     					continue;
825     				}
826     				
827                     String ultManutencao = (acao.getUsuarioUsu() != null) ? acao.getUsuarioUsu().getNomeUsu() : "";
828                     
829                     builder.addClosedNode("acao", 
830                     		"data=\"" + builder.normalize(Pagina.trocaNullData(acao.getDataIetta())) + "\""+
831                     		" descricao=\"" + builder.normalize(Pagina.trocaNull(acao.getDescricaoIetta())) + "\"" +
832                             " ultManutencao=\"" + builder.normalize(ultManutencao) + "\"" +
833                             " dataInclusao=\"" + builder.normalize(Pagina.trocaNullData(acao.getDataInclusaoIetta())) + "\"");
834                 }        
835                 builder.closeNode("acoes");                    
836             }
837         } catch(Exception e){          
838         	this.logger.error(e);
839             throw new ECARException("Erro na criação do relatório: " + label);    
840         }
841     }
842 
843     /**
844      * Gera criterios xml.<br>
845      * 
846      * @author N/C
847      * @since N/C
848      * @version N/C
849      * @param XmlBuilder builder
850      * @param ItemEstruturaIett item
851      * @param String label
852      * @throws ECARException
853      */
854     public void geraXMLCriterios(XmlBuilder builder, ItemEstruturaIett item, String label) throws ECARException{
855         try{            
856             if(item.getItemEstrutCriterioIettcs().size() > 0){
857                 builder.addNode("criterios", "label=\"" + builder.normalize(label) + "\"");
858                 
859                 List criterios = new ArrayList(item.getItemEstrutCriterioIettcs());
860                 Collections.sort(criterios,
861 						new Comparator() {
862 			        		public int compare(Object o1, Object o2) {
863 			        		    return ( (ItemEstrutCriterioIettc)o1 ).getCriterioCri().getDescricaoCri().compareToIgnoreCase( ( (ItemEstrutCriterioIettc)o2 ).getCriterioCri().getDescricaoCri() );
864 			        		}
865 			    		} );                
866                 
867                 //Iterator it = item.getItemEstrutCriterioIettcs().iterator();
868                 Iterator it = criterios.iterator();
869                 while(it.hasNext()){
870                     ItemEstrutCriterioIettc criterio = (ItemEstrutCriterioIettc) it.next();
871                     builder.addAndCloseNode("criterio", builder.normalize(Pagina.trocaNull(criterio.getCriterioCri().getDescricaoCri())));
872                 }        
873                 builder.closeNode("criterios");   
874             }
875         } catch( Exception e){
876         	this.logger.error(e);
877             throw new ECARException("Erro na criação do relatório: " + label);                
878         }
879     }
880 
881     /**
882      * Gera entidades xml.<br>
883      * 
884      * @author N/C
885      * @since N/C
886      * @version N/C
887      * @param XmlBuilder builder
888      * @param ItemEstruturaIett item
889      * @param String label
890      * @throws ECARException
891      */
892     public void geraXMLEntidades(XmlBuilder builder, ItemEstruturaIett item, String label) throws ECARException{
893         try{            
894             if(item.getItemEstrutEntidadeIettes().size() > 0){
895                 builder.addNode("entidades", "label=\"" + builder.normalize(label) + "\"");
896                 Iterator it = item.getItemEstrutEntidadeIettes().iterator();
897                 while(it.hasNext()){
898                     ItemEstrutEntidadeIette entidade = (ItemEstrutEntidadeIette) it.next();
899                     builder.addClosedNode("entidade", "nome=\"" + builder.normalize(Pagina.trocaNull(entidade.getEntidadeEnt().getNomeEnt())) +
900                             "\" atuacao=\"" + builder.normalize(Pagina.trocaNull(entidade.getTipoParticipacaoTpp().getDescricaoTpp())) + "\" inicio=\"" 
901                             + Pagina.trocaNullData(entidade.getDataInicioIette()) + "\" termino=\"" + Pagina.trocaNullData(entidade.getDataFimIette()) + "\" descricao=\""
902                             + builder.normalize(Pagina.trocaNull(entidade.getDescricaoIette())) + "\"");
903                     
904                 }        
905                 builder.closeNode("entidades");                    
906             }            
907         }
908         catch(Exception e){
909         	this.logger.error(e);
910             throw new ECARException("Erro na criação do relatório: " + label);    
911         }
912     }
913     
914     /**
915      * Gera localização xml.<br>
916      * 
917      * @author N/C
918      * @since N/C
919      * @version N/C
920      * @param XmlBuilder builder
921      * @param ItemEstruturaIett item
922      * @param String label
923      * @throws ECARException
924      */
925     public void geraXMLLocalizacao(XmlBuilder builder, ItemEstruturaIett item, String label) throws ECARException{
926         try{
927             if(item.getItemEstrutLocalIettls().size() > 0){
928                 boolean first = true;
929                 
930                 List locais = new ArrayList(item.getItemEstrutLocalIettls());
931                 Collections.sort(locais,
932 						new Comparator() {
933 			        		public int compare(Object o1, Object o2) {
934 			        		    return ( (ItemEstrutLocalIettl)o1 ).getLocalItemLit().getIdentificacaoLit().compareToIgnoreCase( ( (ItemEstrutLocalIettl)o2 ).getLocalItemLit().getIdentificacaoLit() );
935 			        		}
936 			    		} );                 
937                 
938                 //Iterator it = item.getItemEstrutLocalIettls().iterator();        
939                 Iterator it = locais.iterator();
940                 while(it.hasNext()){
941                     ItemEstrutLocalIettl local = (ItemEstrutLocalIettl) it.next();                   
942                     
943                     if(first){
944                         builder.addNode("localizacao", "label=\"" + builder.normalize(label) + "\" abrangencia=\"" + builder.normalize(local.getLocalItemLit().getLocalGrupoLgp().getIdentificacaoLgp()) + "\"");
945                         first = false;
946                     }
947                     builder.addAndCloseNode("local", builder.normalize(Pagina.trocaNull(local.getLocalItemLit().getIdentificacaoLit())));
948                 }        
949                 builder.closeNode("localizacao");                    
950             }
951         } catch (Exception e){
952         	this.logger.error(e);
953             throw new ECARException("Erro na criação do relatório: " + label);               
954         }        
955     }
956     
957     /**
958      * Gera fontes_Recursos xml.<br>
959      * 
960      * @author N/C
961      * @since N/C
962      * @version N/C
963      * @param XmlBuilder builder
964      * @param ItemEstruturaIett item
965      * @param String label
966      * @param boolean exibirRecursos
967      * @throws ECARException
968      */
969     public void geraXMLFontes_Recursos(XmlBuilder builder, ItemEstruturaIett item, String label, 
970     		boolean exibirRecursos) throws ECARException{
971         try{
972         	ExercicioDao exercicioDao = new ExercicioDao(null);
973 
974         	ItemEstruturaPrevisaoDao itemPrevisaoDao = new ItemEstruturaPrevisaoDao(null);
975         	/*
976             if(item.getEfIettFonteTotEfiefts().size() > 0){
977                 builder.addNode("fontesRecurso", "label=\"" + builder.normalize(label) + "\"");
978                 Iterator itFontes = item.getEfIettFonteTotEfiefts().iterator();        
979                 while(itFontes.hasNext()){
980                     EfIettFonteTotEfieft fontes = (EfIettFonteTotEfieft) itFontes.next();
981                     builder.addNode("fonteRecurso", "nome=\"" + builder.normalize(Pagina.trocaNull(fontes.getFonteRecursoFonr().getNomeFonr())) + "\"");
982                     if (exibirRecursos){
983 	                    Iterator itRecursos = new ItemEstruturaPrevisaoDao(null).getRecursosByFonteRecurso(fontes.getFonteRecursoFonr().getCodFonr(), fontes.getItemEstruturaIett().getCodIett()).iterator();
984 	                    
985 	                    long codRecurso = -1;
986 	                    while(itRecursos.hasNext()){
987 	                        EfItemEstPrevisaoEfiep recurso = (EfItemEstPrevisaoEfiep) itRecursos.next();
988 	                        String nomeRecurso = "";
989 	                        if(recurso.getRecursoRec().getCodRec().longValue() != codRecurso){
990 	                        	nomeRecurso = recurso.getRecursoRec().getNomeRec();
991 	                        	codRecurso = recurso.getRecursoRec().getCodRec().longValue();
992 	                        }
993 	                        
994 	                        builder.addClosedNode("recurso", 
995 	                        		"nome=\"" + builder.normalize(nomeRecurso) + "\"" +
996 	                        		//" valorAprovado=\"" + Util.formataMoeda(recurso.getValorAprovadoEfiep().doubleValue()) + "\"" +
997 	                        		//" valorRevisado=\"" + Util.formataMoeda(recurso.getValorRevisadoEfiep().doubleValue()) + "\"" +
998 	                        		" valorAprovado=\"" + Util.formataNumeroSemDecimal(recurso.getValorAprovadoEfiep().setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue()) + "\"" +
999 	                        		" valorRevisado=\"" + Util.formataNumeroSemDecimal(recurso.getValorRevisadoEfiep().setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue()) + "\"" +
1000 	                        		" exercicio=\"" + builder.normalize(recurso.getExercicioExe().getDescricaoExe()) + "\"");
1001 	                    }
1002                     }
1003                     builder.closeNode("fonteRecurso");
1004                 }        
1005                 builder.closeNode("fontesRecurso");                    
1006             }*/
1007         	
1008         	if(item.getEfIettFonteTotEfiefts().size() > 0){
1009         		
1010         		boolean exibirQuadroTotais = false;
1011         		List totaisExercicios = exercicioDao.getExerciciosValidos(item.getCodIett());
1012         		int qtdeExeGeral = totaisExercicios.size();
1013         		double[] totAprovGeral = new double[qtdeExeGeral];
1014         		double[] totRevGeral = new double[qtdeExeGeral];
1015         		
1016         		for(int i = 0; i < qtdeExeGeral; i++){
1017         			totAprovGeral[i] = 0;
1018         			totRevGeral[i] = 0;
1019         		}
1020         		
1021         		builder.addNode("fontesRecurso", "label=\"" + builder.normalize(label) + "\"");
1022         		
1023         		Iterator itFontes = item.getEfIettFonteTotEfiefts().iterator();
1024         		while(itFontes.hasNext()){
1025         			EfIettFonteTotEfieft fontes = (EfIettFonteTotEfieft) itFontes.next();
1026         			builder.addNode("fonteRecurso");
1027         			
1028         			if (exibirRecursos){
1029         				List listaRecursos = itemPrevisaoDao.getRecursosByFonteRecurso(fontes.getComp_id().getCodFonr(), item.getCodIett(), Dominios.SIM);
1030         				if(listaRecursos != null && listaRecursos.size() > 0){
1031         					
1032         					exibirQuadroTotais = true;
1033         					
1034         					List listaItemRec = itemPrevisaoDao.getRecursosByFonteRecurso(fontes.getFonteRecursoFonr().getCodFonr(), fontes.getItemEstruturaIett().getCodIett(), Dominios.SIM);
1035         					Iterator itItemRec = listaItemRec.iterator();
1036         					
1037         					List listaExercicios = exercicioDao.getExerciciosValidos(item.getCodIett());
1038 							Iterator itExerc = listaExercicios.iterator();
1039 							
1040 							int numExe = 0;
1041 
1042 							/* Monta o Cabeçalho da Tabela
1043 							 * | Recurso | Valor | 2004 | 2005 | 2006 | 2007 | Total |
1044 							 * */
1045 							builder.addNode("fonteRecursoCabecalho");
1046 							
1047 							builder.addClosedNode("itemCabecalho", "tam=\"2.5cm\"");
1048 							builder.addClosedNode("itemCabecalho", "tam=\"2.7cm\"");
1049 							//builder.addClosedNode("exercicioRecurso", "exercicio=\"Recurso\" alinhamento=\"justify\"");
1050 							builder.addClosedNode("exercicioRecurso", "exercicio=\"" + builder.normalize(fontes.getFonteRecursoFonr().getNomeFonr()) +"\" alinhamento=\"justify\"");
1051 							builder.addClosedNode("exercicioRecurso", "exercicio=\"Valor\" alinhamento=\"justify\"");
1052 							while (itExerc.hasNext()) {
1053 								ExercicioExe exercicio = (ExercicioExe) itExerc.next();
1054 								numExe++;
1055 								builder.addClosedNode("itemCabecalho", "tam=\"3.0cm\"");
1056 								builder.addClosedNode("exercicioRecurso", "exercicio=\"" + builder.normalize(exercicio.getDescricaoExe()) + "\" alinhamento=\"right\"");
1057 							}
1058 							builder.addClosedNode("itemCabecalho", "tam=\"3.3cm\"");
1059 							builder.addClosedNode("exercicioRecurso", "exercicio=\"Total\" alinhamento=\"right\"");
1060 	        				builder.closeNode("fonteRecursoCabecalho");
1061 
1062 	        				/* Criar os Arrays de valores Aprovados e Revisados conforme qtde de exercícios*/
1063 							double[] totalAprovExe = new double[numExe];
1064 							double[] totalRevExe = new double[numExe];
1065 							itExerc = listaExercicios.iterator();
1066 							numExe = 0;
1067 							while (itExerc.hasNext()) {
1068 								ExercicioExe exercicio = (ExercicioExe) itExerc.next();
1069 								totalAprovExe[numExe] = 0;
1070 								totalRevExe[numExe] = 0;
1071 								numExe++;
1072 							}
1073 							
1074 							
1075 							int col = 0;
1076 							String valorCampo = "";
1077 							String alinhamento = "";
1078 
1079 							/*buscar os valores para cada recurso da fonte de recursos*/
1080 							List listaRec = itemPrevisaoDao.getRecursosDistintosByFonteRecurso(fontes.getFonteRecursoFonr().getCodFonr(), fontes.getItemEstruturaIett().getCodIett());
1081 							Iterator itRec = listaRec.iterator();
1082 							
1083 							while (itRec.hasNext()) {
1084 								RecursoRec recurso = (RecursoRec) itRec.next();
1085 								double totalAprovRec = 0;
1086 								double totalRevRec = 0;
1087 
1088 								builder.addNode("recursos");
1089 								
1090 								/*Valores Aprovados*/
1091 								String nomeRecurso = recurso.getNomeRec();
1092 								String valorRecurso = "Aprovado";
1093 								valorCampo = "";
1094 
1095 								builder.addClosedNode("itemRecurso", "tam=\"2mm\"");
1096 								builder.addClosedNode("itemRecurso", "tam=\"2.3cm\"");
1097 								builder.addClosedNode("itemRecurso", "tam=\"2.7cm\"");
1098 								builder.addClosedNode("recurso", "valor=\"\" alinhamento=\"justify\" conteudo=\"N\"");
1099 								builder.addClosedNode("recurso", "valor=\"" + builder.normalize(nomeRecurso) + "\" alinhamento=\"justify\" conteudo=\"S\"");
1100 								builder.addClosedNode("recurso", "valor=\"" + builder.normalize(valorRecurso) + "\" alinhamento=\"justify\" conteudo=\"S\"");
1101 								
1102 								col = 0;
1103 								itExerc = listaExercicios.iterator();
1104 								while (itExerc.hasNext()) {
1105 									ExercicioExe exercicio = (ExercicioExe) itExerc.next();
1106 									
1107 									valorCampo = "-";
1108 									alinhamento = "center";
1109 									itItemRec = listaItemRec.iterator();
1110 									while (itItemRec.hasNext()) {
1111 										EfItemEstPrevisaoEfiep ieRecurso = (EfItemEstPrevisaoEfiep) itItemRec.next();
1112 										if (ieRecurso.getExercicioExe().equals(exercicio) && 
1113 													ieRecurso.getRecursoRec().equals(recurso)) {
1114 											
1115 											valorCampo = Pagina.trocaNullMoeda(ieRecurso.getValorAprovadoEfiep());
1116 											alinhamento = "right";
1117 											if(ieRecurso.getValorAprovadoEfiep() != null){
1118 												totalAprovRec = totalAprovRec + ieRecurso.getValorAprovadoEfiep().doubleValue();
1119 												totalAprovExe[col] = totalAprovExe[col] + ieRecurso.getValorAprovadoEfiep().doubleValue();
1120 												totAprovGeral[col] = totAprovGeral[col] + ieRecurso.getValorAprovadoEfiep().doubleValue();
1121 											}
1122 											
1123 										}
1124 									}
1125 									builder.addClosedNode("itemRecurso", "tam=\"3.0cm\"");
1126 									builder.addClosedNode("recurso", "valor=\"" + builder.normalize(valorCampo) + "\" alinhamento=\""+ builder.normalize(alinhamento) +"\" conteudo=\"S\"");
1127 									col++;
1128 								}
1129 								builder.addClosedNode("itemRecurso", "tam=\"3.3cm\"");
1130 								builder.addClosedNode("recurso", "valor=\"" + builder.normalize(Util.formataMoeda(totalAprovRec)) + "\" alinhamento=\"right\" conteudo=\"S\"");
1131 
1132 								builder.closeNode("recursos");
1133 								builder.addNode("recursos");
1134 								
1135 								/*Valores Revisados*/
1136 								nomeRecurso = "";
1137 								valorRecurso = "Revisado";
1138 								valorCampo = "";
1139 
1140 								builder.addClosedNode("itemRecurso", "tam=\"2mm\"");
1141 								builder.addClosedNode("itemRecurso", "tam=\"2.3cm\"");
1142 								builder.addClosedNode("itemRecurso", "tam=\"2.7cm\"");
1143 								builder.addClosedNode("recurso", "valor=\"\" alinhamento=\"justify\" conteudo=\"N\"");
1144 								builder.addClosedNode("recurso", "valor=\"" + builder.normalize(nomeRecurso) + "\" alinhamento=\"justify\" conteudo=\"S\"");
1145 								builder.addClosedNode("recurso", "valor=\"" + builder.normalize(valorRecurso) + "\" alinhamento=\"justify\" conteudo=\"S\"");
1146 								
1147 								col = 0;
1148 								itExerc = listaExercicios.iterator();
1149 								while (itExerc.hasNext()) {
1150 									ExercicioExe exercicio = (ExercicioExe) itExerc.next();
1151 									
1152 									valorCampo = "-";
1153 									alinhamento = "center";
1154 									itItemRec = listaItemRec.iterator();
1155 									while (itItemRec.hasNext()) {
1156 										EfItemEstPrevisaoEfiep ieRecurso = (EfItemEstPrevisaoEfiep) itItemRec.next();
1157 										if (ieRecurso.getExercicioExe().equals(exercicio) && 
1158 													ieRecurso.getRecursoRec().equals(recurso)) {
1159 											
1160 											valorCampo = Pagina.trocaNullMoeda(ieRecurso.getValorRevisadoEfiep());
1161 											alinhamento = "right";
1162 											if(ieRecurso.getValorRevisadoEfiep() != null){
1163 												totalRevRec += ieRecurso.getValorRevisadoEfiep().doubleValue();
1164 												totalRevExe[col] += ieRecurso.getValorRevisadoEfiep().doubleValue();
1165 												totRevGeral[col] += ieRecurso.getValorRevisadoEfiep().doubleValue();
1166 											}
1167 										}
1168 									}
1169 									builder.addClosedNode("itemRecurso", "tam=\"3.0cm\"");
1170 									builder.addClosedNode("recurso", "valor=\"" + builder.normalize(valorCampo) + "\" alinhamento=\""+ builder.normalize(alinhamento) +"\" conteudo=\"S\"");
1171 									col++;
1172 								}
1173 								builder.addClosedNode("itemRecurso", "tam=\"3.3cm\"");
1174 								builder.addClosedNode("recurso", "valor=\"" + builder.normalize(Util.formataMoeda(totalRevRec)) + "\" alinhamento=\"right\" conteudo=\"S\"");
1175 								
1176 								
1177 								builder.closeNode("recursos");
1178 							}
1179 							
1180 							/*Mostra o Rodapé da Tabela*/
1181 							builder.addNode("fonteRecursosRodape");
1182 							
1183 							/*Total Aprovado*/
1184 							valorCampo = "";
1185 							builder.addNode("linhaTotal");
1186 							builder.addClosedNode("itemTotal", "tam=\"2mm\"");
1187 							builder.addClosedNode("itemTotal", "tam=\"2.3cm\"");
1188 							builder.addClosedNode("itemTotal", "tam=\"2.7cm\"");
1189 							builder.addClosedNode("linha", "valor=\"\" alinhamento=\"justify\" borda=\"\" conteudo=\"N\" corFundo=\"#CCC\"");
1190 							builder.addClosedNode("linha", "valor=\"\" alinhamento=\"justify\" borda=\"cima\" conteudo=\"N\" corFundo=\"#CCC\"");
1191 							builder.addClosedNode("linha", "valor=\"Total Aprovado\" alinhamento=\"justify\" borda=\"cima\" conteudo=\"S\" corFundo=\"#CCC\"");
1192 
1193 							col = 0;
1194 							double totalAprovadoGeral = 0;
1195 							Iterator itTotAprov = listaExercicios.iterator();
1196 							while (itTotAprov.hasNext()) {
1197 								ExercicioExe exercicio = (ExercicioExe) itTotAprov.next();
1198 								
1199 								valorCampo = Util.formataMoeda(totalAprovExe[col]);
1200 								totalAprovadoGeral = totalAprovadoGeral + totalAprovExe[col];
1201 								col++;
1202 								builder.addClosedNode("itemTotal", "tam=\"3.0cm\"");
1203 								builder.addClosedNode("linha", "valor=\"" + builder.normalize(valorCampo)+ "\" alinhamento=\"right\" borda=\"cima\" conteudo=\"S\" corFundo=\"#FFF\"");
1204 							}
1205 							builder.addClosedNode("itemTotal", "tam=\"3.3cm\"");
1206 							builder.addClosedNode("linha", "valor=\"" + builder.normalize(Util.formataMoeda(totalAprovadoGeral)) + "\" alinhamento=\"right\" borda=\"cima\" conteudo=\"S\" corFundo=\"#FFF\"");
1207 							builder.closeNode("linhaTotal");
1208 
1209 							/*Total Revisado*/
1210 							valorCampo = "";
1211 							builder.addNode("linhaTotal");
1212 							builder.addClosedNode("itemTotal", "tam=\"2mm\"");
1213 							builder.addClosedNode("itemTotal", "tam=\"2.3cm\"");
1214 							builder.addClosedNode("itemTotal", "tam=\"2.7cm\"");
1215 							builder.addClosedNode("linha", "valor=\"\" alinhamento=\"justify\" borda=\"\" conteudo=\"N\" corFundo=\"#CCC\"");
1216 							builder.addClosedNode("linha", "valor=\"\" alinhamento=\"justify\" borda=\"\" conteudo=\"N\" corFundo=\"#CCC\"");
1217 							builder.addClosedNode("linha", "valor=\"Total Revisado\" alinhamento=\"justify\" borda=\"\" conteudo=\"S\" corFundo=\"#CCC\"");
1218 
1219 							col = 0;
1220 							double totalRevisadoGeral = 0;
1221 							Iterator itTotRev = listaExercicios.iterator();
1222 							while (itTotRev.hasNext()) {
1223 								ExercicioExe exercicio = (ExercicioExe) itTotRev.next();
1224 								
1225 								valorCampo = Util.formataMoeda(totalRevExe[col]);
1226 								totalRevisadoGeral += totalRevExe[col];
1227 								col++;
1228 								builder.addClosedNode("itemTotal", "tam=\"3.0cm\"");
1229 								builder.addClosedNode("linha", "valor=\"" + builder.normalize(valorCampo)+ "\" alinhamento=\"right\" borda=\"\" conteudo=\"S\" corFundo=\"#CCC\"");
1230 							}
1231 							builder.addClosedNode("itemTotal", "tam=\"3.3cm\"");
1232 							builder.addClosedNode("linha", "valor=\"" + builder.normalize(Util.formataMoeda(totalRevisadoGeral)) + "\" alinhamento=\"right\" borda=\"\" conteudo=\"S\" corFundo=\"#CCC\"");
1233 							builder.closeNode("linhaTotal");
1234 							
1235 							/*Aumento/Redução*/
1236 							valorCampo = "";
1237 							builder.addNode("linhaTotal");
1238 							builder.addClosedNode("itemTotal", "tam=\"2mm\"");
1239 							builder.addClosedNode("itemTotal", "tam=\"2.3cm\"");
1240 							builder.addClosedNode("itemTotal", "tam=\"2.7cm\"");
1241 							builder.addClosedNode("linha", "valor=\"\" alinhamento=\"justify\" borda=\"\" conteudo=\"N\" corFundo=\"#CCC\"");
1242 							builder.addClosedNode("linha", "valor=\"\" alinhamento=\"justify\" borda=\"\" conteudo=\"N\" corFundo=\"#CCC\"");
1243 							builder.addClosedNode("linha", "valor=\"Aumento/Redução\" alinhamento=\"justify\" borda=\"baixo\" conteudo=\"S\" corFundo=\"#CCC\"");
1244 
1245 							col = 0;
1246 							Iterator itDif = listaExercicios.iterator();
1247 							while (itDif.hasNext()) {
1248 								ExercicioExe exercicio = (ExercicioExe) itDif.next();
1249 								
1250 								valorCampo = Util.formataMoeda(totalRevExe[col] - totalAprovExe[col]);
1251 								col++;
1252 								builder.addClosedNode("itemTotal", "tam=\"3.0cm\"");
1253 								builder.addClosedNode("linha", "valor=\"" + builder.normalize(valorCampo)+ "\" alinhamento=\"right\" borda=\"baixo\" conteudo=\"S\" corFundo=\"#FFF\"");
1254 							}
1255 							
1256 							double difTotal = totalRevisadoGeral - totalAprovadoGeral;
1257 							
1258 							builder.addClosedNode("itemTotal", "tam=\"3.3cm\"");
1259 							builder.addClosedNode("linha", "valor=\"" + builder.normalize(Util.formataMoeda(difTotal)) + "\" alinhamento=\"right\" borda=\"baixo\" conteudo=\"S\" corFundo=\"#FFF\"");
1260 							builder.closeNode("linhaTotal");
1261 
1262 							builder.closeNode("fonteRecursosRodape");
1263         				}
1264         			}
1265         			
1266         			builder.closeNode("fonteRecurso");
1267         		}
1268         		
1269         		if(exibirQuadroTotais){
1270         			/* Início da montagem da tabela de totais gerais */
1271         			builder.addNode("fonteTotais");
1272 
1273         			/* Monta o Cabeçalho da Tabela de totais
1274 					 * | TOTAIS | Valor | 2004 | 2005 | 2006 | 2007 | Total |
1275 					 * */
1276 					builder.addNode("fonteTotaisCabecalho");
1277 					
1278 					builder.addClosedNode("itemTotaisCabecalho", "tam=\"2.5cm\"");
1279 					builder.addClosedNode("itemTotaisCabecalho", "tam=\"2.7cm\"");
1280 					builder.addClosedNode("exercicioTotais", "exercicio=\"TOTAIS\" alinhamento=\"justify\"");
1281 					builder.addClosedNode("exercicioTotais", "exercicio=\"Valor\" alinhamento=\"justify\"");
1282 					
1283 					int colunasExercicios = 0;
1284 					
1285 					Iterator itExercFinal = totaisExercicios.iterator();
1286 					while (itExercFinal.hasNext()) {
1287 						ExercicioExe exercicio = (ExercicioExe) itExercFinal.next();
1288 						colunasExercicios++;
1289 						builder.addClosedNode("itemTotaisCabecalho", "tam=\"3.0cm\"");
1290 						builder.addClosedNode("exercicioTotais", "exercicio=\"" + builder.normalize(exercicio.getDescricaoExe()) + "\" alinhamento=\"right\"");
1291 					}
1292 					builder.addClosedNode("itemTotaisCabecalho", "tam=\"3.3cm\"");
1293 					builder.addClosedNode("exercicioTotais", "exercicio=\"Total\" alinhamento=\"right\"");
1294     				builder.closeNode("fonteTotaisCabecalho");
1295     				
1296     				/* Monta linha de valores aprovados totais */
1297 					/*Total Aprovado*/
1298 					String valorCampoTotais = "";
1299 					builder.addNode("linhaTotalGeral");
1300 					builder.addClosedNode("itemTotalGeral", "tam=\"2mm\"");
1301 					builder.addClosedNode("itemTotalGeral", "tam=\"2.3cm\"");
1302 					builder.addClosedNode("itemTotalGeral", "tam=\"2.7cm\"");
1303 					builder.addClosedNode("linhaGeral", "valor=\"\" alinhamento=\"justify\" borda=\"\" conteudo=\"N\" corFundo=\"#CCC\"");
1304 					builder.addClosedNode("linhaGeral", "valor=\"\" alinhamento=\"justify\" borda=\"cima\" conteudo=\"N\" corFundo=\"#CCC\"");
1305 					builder.addClosedNode("linhaGeral", "valor=\"Total Aprovado\" alinhamento=\"justify\" borda=\"cima\" conteudo=\"S\" corFundo=\"#CCC\"");
1306 
1307 					double totalAprovadoGeral = 0;
1308 					
1309 					for(int col = 0; col < colunasExercicios; col++){
1310 						valorCampoTotais = Util.formataMoeda(totAprovGeral[col]);
1311 						totalAprovadoGeral = totalAprovadoGeral + totAprovGeral[col];
1312 						builder.addClosedNode("itemTotalGeral", "tam=\"3.0cm\"");
1313 						builder.addClosedNode("linhaGeral", "valor=\"" + builder.normalize(valorCampoTotais)+ "\" alinhamento=\"right\" borda=\"cima\" conteudo=\"S\" corFundo=\"#FFF\"");
1314 					}
1315 					builder.addClosedNode("itemTotalGeral", "tam=\"3.3cm\"");
1316 					builder.addClosedNode("linhaGeral", "valor=\"" + builder.normalize(Util.formataMoeda(totalAprovadoGeral)) + "\" alinhamento=\"right\" borda=\"cima\" conteudo=\"S\" corFundo=\"#FFF\"");
1317 					builder.closeNode("linhaTotalGeral");
1318 
1319     				/* Monta linha de valores revisados totais */
1320 					/*Total Revisado*/
1321 					valorCampoTotais = "";
1322 					builder.addNode("linhaTotalGeral");
1323 					builder.addClosedNode("itemTotalGeral", "tam=\"2mm\"");
1324 					builder.addClosedNode("itemTotalGeral", "tam=\"2.3cm\"");
1325 					builder.addClosedNode("itemTotalGeral", "tam=\"2.7cm\"");
1326 					builder.addClosedNode("linhaGeral", "valor=\"\" alinhamento=\"justify\" borda=\"\" conteudo=\"N\" corFundo=\"#CCC\"");
1327 					builder.addClosedNode("linhaGeral", "valor=\"\" alinhamento=\"justify\" borda=\"\" conteudo=\"N\" corFundo=\"#CCC\"");
1328 					builder.addClosedNode("linhaGeral", "valor=\"Total Revisado\" alinhamento=\"justify\" borda=\"\" conteudo=\"S\" corFundo=\"#CCC\"");
1329 
1330 					double totalRevisadoGeral = 0;
1331 
1332 					for(int col = 0; col < colunasExercicios; col++){
1333 						valorCampoTotais = Util.formataMoeda(totRevGeral[col]);
1334 						totalRevisadoGeral = totalRevisadoGeral + totRevGeral[col];
1335 						builder.addClosedNode("itemTotalGeral", "tam=\"3.0cm\"");
1336 						builder.addClosedNode("linhaGeral", "valor=\"" + builder.normalize(valorCampoTotais)+ "\" alinhamento=\"right\" borda=\"\" conteudo=\"S\" corFundo=\"#CCC\"");
1337 					}
1338 					
1339 					builder.addClosedNode("itemTotalGeral", "tam=\"3.3cm\"");
1340 					builder.addClosedNode("linhaGeral", "valor=\"" + builder.normalize(Util.formataMoeda(totalRevisadoGeral)) + "\" alinhamento=\"right\" borda=\"\" conteudo=\"S\" corFundo=\"#CCC\"");
1341 					builder.closeNode("linhaTotalGeral");
1342 					
1343     				/* Monta linha de valores Aumento/Redução totais */
1344 					/*Aumento/Redução*/
1345 					valorCampoTotais = "";
1346 					builder.addNode("linhaTotalGeral");
1347 					builder.addClosedNode("itemTotalGeral", "tam=\"2mm\"");
1348 					builder.addClosedNode("itemTotalGeral", "tam=\"2.3cm\"");
1349 					builder.addClosedNode("itemTotalGeral", "tam=\"2.7cm\"");
1350 					builder.addClosedNode("linhaGeral", "valor=\"\" alinhamento=\"justify\" borda=\"\" conteudo=\"N\" corFundo=\"#CCC\"");
1351 					builder.addClosedNode("linhaGeral", "valor=\"\" alinhamento=\"justify\" borda=\"baixo\" conteudo=\"N\" corFundo=\"#CCC\"");
1352 					builder.addClosedNode("linhaGeral", "valor=\"Aumento/Redução\" alinhamento=\"justify\" borda=\"baixo\" conteudo=\"S\" corFundo=\"#CCC\"");
1353 
1354 
1355 					for(int col = 0; col < colunasExercicios; col++){
1356 						valorCampoTotais = Util.formataMoeda(totRevGeral[col] - totAprovGeral[col]);
1357 						
1358 						builder.addClosedNode("itemTotalGeral", "tam=\"3.0cm\"");
1359 						builder.addClosedNode("linhaGeral", "valor=\"" + builder.normalize(valorCampoTotais)+ "\" alinhamento=\"right\" borda=\"baixo\" conteudo=\"S\" corFundo=\"#FFF\"");
1360 					}
1361 					
1362 					double difTotal = totalRevisadoGeral - totalAprovadoGeral;
1363 					
1364 					builder.addClosedNode("itemTotalGeral", "tam=\"3.3cm\"");
1365 					builder.addClosedNode("linhaGeral", "valor=\"" + builder.normalize(Util.formataMoeda(difTotal)) + "\" alinhamento=\"right\" borda=\"baixo\" conteudo=\"S\" corFundo=\"#FFF\"");
1366 					builder.closeNode("linhaTotalGeral");
1367         			builder.closeNode("fonteTotais");
1368         			/* Fim da montagem da tabela de totais gerais */
1369         		}
1370         		
1371         		builder.closeNode("fontesRecurso");
1372         	}
1373         	
1374         } catch (Exception e){
1375         	this.logger.error(e);
1376             throw new ECARException("Erro na criação do relatório: " + label);            
1377         }
1378     }
1379     
1380     /**
1381      * Soma total Aprovado Revisado.<br>
1382      * 
1383      * @author N/C
1384      * @since N/C
1385      * @version N/C
1386      * @param EfIettFonteTotEfieft fonteRecurso
1387      * @param String tipo
1388      * @return String
1389      * @throws ECARException
1390      */
1391     public String somarTotalAprovadoRevisado(EfIettFonteTotEfieft fonteRecurso, String tipo) throws ECARException{
1392     	ItemEstruturaFonteRecursoDao fonteRecursoDao = new ItemEstruturaFonteRecursoDao(null);
1393     	double total = fonteRecursoDao.getSomaRecursosFonteRecurso(fonteRecurso, tipo);
1394         return Util.formataMoeda(total); 
1395     }
1396 
1397     /**
1398      * Gera pontos_criticos xml.<br>
1399      * 
1400      * @author N/C
1401      * @since N/C
1402      * @version N/C
1403      * @param XmlBuilder builder
1404      * @param ItemEstruturaIett item
1405      * @param String label
1406      * @param boolean exibirApontamentos
1407      * @throws ECARException
1408      */
1409     public void geraXMLPontos_Criticos(XmlBuilder builder, ItemEstruturaIett item, String label, 
1410     		boolean exibirApontamentos) throws ECARException{
1411         try{            
1412             if(item.getPontoCriticoPtcs().size() > 0){
1413                 builder.addNode("pontosCriticos", "label=\"" + builder.normalize(label) + "\"");
1414                 Iterator it = item.getPontoCriticoPtcs().iterator();
1415                 while(it.hasNext()){
1416                     PontoCriticoPtc ponto = (PontoCriticoPtc) it.next();
1417                     String ambito = "";
1418                     if("I".equals(ponto.getIndAmbitoInternoGovPtc()))
1419                         ambito = "Interno";
1420                     if("E".equals(ponto.getIndAmbitoInternoGovPtc()))
1421                         ambito = "Externo";
1422                     String nomeUsuario = "";
1423                     if(ponto.getUsuarioUsu() != null)
1424                         nomeUsuario = ponto.getUsuarioUsu().getNomeUsuSent();
1425                     
1426                     /*
1427                     builder.addClosedNode("pontoCritico", "dataIdentificacao=\"" + Pagina.trocaNullData(ponto.getDataIdentificacaoPtc()) + "\" descricao=\"" 
1428                             + builder.normalize(Pagina.trocaNull(ponto.getDescricaoPtc())) + "\" ambitoDoGoverno=\"" + builder.normalize(ambito) + "\" dataLimiteSolucao=\""
1429                             + Pagina.trocaNullData(ponto.getDataLimitePtc()) + "\" sugestao=\"" + builder.normalize(Pagina.trocaNull(ponto.getDescricaoSolucaoPtc())) + "\" "
1430                             + " dataSolucao=\"" + Pagina.trocaNullData(ponto.getDataSolucaoPtc()) + "\" responsavel=\"" + builder.normalize(nomeUsuario) + "\"");
1431                     */
1432                     builder.addNode("pontoCritico", "dataIdentificacao=\"" + Pagina.trocaNullData(ponto.getDataIdentificacaoPtc()) + "\" descricao=\"" 
1433                             + builder.normalize(Pagina.trocaNull(ponto.getDescricaoPtc())) + "\" ambitoDoGoverno=\"" + builder.normalize(ambito) + "\" dataLimiteSolucao=\""
1434                             + Pagina.trocaNullData(ponto.getDataLimitePtc()) + "\" sugestao=\"" + builder.normalize(Pagina.trocaNull(ponto.getDescricaoSolucaoPtc())) + "\" "
1435                             + " dataSolucao=\"" + Pagina.trocaNullData(ponto.getDataSolucaoPtc()) + "\" responsavel=\"" + builder.normalize(nomeUsuario) + "\"");
1436                     if(exibirApontamentos && ponto.getApontamentoApts() != null && ponto.getApontamentoApts().size() > 0){
1437                     	Iterator itApontamentos = ponto.getApontamentoApts().iterator();
1438                     	while(itApontamentos.hasNext()){
1439                     		ApontamentoApt apontamento = (ApontamentoApt) itApontamentos.next();
1440                     		builder.addClosedNode("apontamento", "dataInclusao=\"" + Pagina.trocaNullData(apontamento.getDataInclusaoApt()) + "\"" +
1441                     				" texto=\"" + builder.normalize(apontamento.getTextoApt()) + "\""); 
1442                     	}
1443                     }
1444                     builder.closeNode("pontoCritico");
1445                 }        
1446                 builder.closeNode("pontosCriticos");                    
1447             }            
1448         } catch(Exception e){
1449         	this.logger.error(e);
1450             throw new ECARException("Erro na criação do relatório: " + label);              
1451         }
1452     }
1453     
1454     /**
1455      * Gera categorias xml.<br>
1456      * 
1457      * @author N/C
1458      * @since N/C
1459      * @version N/C
1460      * @param XmlBuilder builder
1461      * @param ItemEstruturaIett item
1462      * @param String label
1463      * @param boolean exibirItensAnexo
1464      * @param boolean exibirCategoriaSemItemAnexo
1465      * @throws ECARException
1466      */
1467     public void geraXMLCategorias(XmlBuilder builder, ItemEstruturaIett item, String label, 
1468     		boolean exibirItensAnexo, boolean exibirCategoriaSemItemAnexo) throws ECARException{
1469         try{
1470         	if(item.getItemEstrUplCategIettucs() != null && item.getItemEstrUplCategIettucs().size() > 0){
1471             	builder.addNode("categorias", "label=\"" + builder.normalize(label) + "\"");
1472         		Iterator itCategorias = item.getItemEstrUplCategIettucs().iterator();
1473         		while (itCategorias.hasNext()){
1474         			ItemEstrUplCategIettuc categoria = (ItemEstrUplCategIettuc) itCategorias.next();
1475     				if (!exibirCategoriaSemItemAnexo && (categoria.getItemEstrutUploadIettups() == null || categoria.getItemEstrutUploadIettups().isEmpty())) {
1476     					continue;
1477     				}
1478 
1479     				String nomeCat = categoria.getNomeIettuc(); 
1480         			String tipoCat = "";
1481         			if (categoria.getUploadTipoCategoriaUtc() != null){
1482         				tipoCat = categoria.getUploadTipoCategoriaUtc().getNomeUtc();
1483         			}
1484         			builder.addNode("categoria", "nome=\"" + builder.normalize(nomeCat) + "\"" +
1485         					" tipo=\"" + builder.normalize(tipoCat) + "\"");
1486         			if (exibirItensAnexo){
1487         				if (categoria.getItemEstrutUploadIettups() != null && !categoria.getItemEstrutUploadIettups().isEmpty()) {
1488         					Iterator itAnexos = categoria.getItemEstrutUploadIettups().iterator();
1489         					
1490         					String nomeAnexo = "";
1491     						String descAnexo = "";
1492     						String tamanhoAnexo = "";
1493     						
1494         					while (itAnexos.hasNext()){
1495         						ItemEstrutUploadIettup anexo = (ItemEstrutUploadIettup) itAnexos.next();
1496         						        	
1497         						if (anexo.getNomeOriginalIettup() != null)
1498         							nomeAnexo = anexo.getNomeOriginalIettup();
1499         						
1500         						if (anexo.getDescricaoIettup() != null)
1501         							descAnexo = anexo.getDescricaoIettup();
1502         						
1503         						if (anexo.getTamanhoIettup() != null)
1504         							tamanhoAnexo = Util.formataByte(anexo.getTamanhoIettup());
1505         						
1506         						builder.addClosedNode("anexo", "nomeOriginal=\"" + builder.normalize(nomeAnexo) + "\"" +
1507         								" descricao=\"" + builder.normalize(descAnexo) + "\"" +
1508         								" tamanho=\"" + builder.normalize(tamanhoAnexo) + "\"");
1509         					}
1510         				}
1511         			}
1512         			builder.closeNode("categoria");
1513         		}
1514             	builder.closeNode("categorias");
1515         	}
1516         } catch (Exception e){
1517         	this.logger.error(e);
1518             throw new ECARException("Erro na criação do relatório: " + label);            
1519         }
1520     }
1521 
1522     /**
1523      * Gera contas do orçamento xml.<br>
1524      * 
1525      * @author N/C
1526      * @since N/C
1527      * @version N/C
1528      * @param XmlBuilder builder
1529      * @param ItemEstruturaIett item
1530      * @param String label
1531      * @throws ECARException
1532      */
1533 //    public void geraXMLContas(XmlBuilder builder, ItemEstruturaIett item, String label) throws ECARException {
1534       public void geraXMLContas_do_Orcamento(XmlBuilder builder, ItemEstruturaIett item, String label) throws ECARException {
1535         try{
1536             if (item.getEfItemEstContaEfiecs().size() > 0){
1537                 builder.addNode("contas", "label=\"" + builder.normalize(label) + "\" nomeColunaConta=\"" + builder.normalize(ItemEstruturaContaOrcamentoDao.geraLabelCadastroEstruturaConta(null)) + "\"");
1538                 Iterator it = item.getEfItemEstContaEfiecs().iterator();
1539                 while(it.hasNext()){
1540                     EfItemEstContaEfiec conta = (EfItemEstContaEfiec) it.next();
1541                     String acumulado = "";
1542                     if("S".equals(conta.getIndAcumuladoEfiec()))
1543                         acumulado = "Sim";
1544                     if("N".equals(conta.getIndAcumuladoEfiec()))
1545                         acumulado = "Não";
1546                     
1547                     builder.addClosedNode("conta", "fonteRecurso=\"" + builder.normalize(Pagina.trocaNull(conta.getFonteRecursoFonr().getNomeFonr())) + "/" + builder.normalize(Pagina.trocaNull(conta.getRecursoRec().getNomeRec()))
1548                             + "\" exercicio=\"" + builder.normalize(Pagina.trocaNull(conta.getExercicioExe().getDescricaoExe())) + "\" acumulado=\"" 
1549                             + builder.normalize(acumulado) + "\" estrutura=\"" + builder.normalize(Pagina.trocaNull(conta.getContaSistemaOrcEfiec())) + "\"");
1550                     
1551                 }        
1552                 builder.closeNode("contas");                              
1553             }                                
1554         }catch(ECARException e){
1555         	this.logger.error(e);
1556             throw new ECARException("Erro na criação do relatório: " + label);    
1557         }        
1558     }
1559 
1560       /**
1561        * Gera indicadores de resultado XML.<br>
1562        * 
1563        * @author N/C
1564        * @since N/C
1565        * @version N/C
1566        * @param XmlBuilder builder
1567        * @param ItemEstruturaIett item
1568        * @param String label
1569        * @param boolean mostrarQuantidades
1570        * @throws ECARException
1571        */
1572       public void geraXMLIndicadores_Resultado(XmlBuilder builder, ItemEstruturaIett item, String label, boolean mostrarQuantidades) throws ECARException{
1573         try{
1574             if(item.getItemEstrtIndResulIettrs().size() > 0){
1575                 builder.addNode("indicadoresResultado", "label=\"" + label + "\"");
1576                 Iterator itIndicadores = item.getItemEstrtIndResulIettrs().iterator();        
1577                 while(itIndicadores.hasNext()){
1578                     ItemEstrtIndResulIettr indicador = (ItemEstrtIndResulIettr) itIndicadores.next();
1579                     String projecoes = "";
1580                     String totalizacoes = "";
1581                     String valorFinal = "";
1582                     if("S".equals(indicador.getIndProjecaoIettr()))
1583                         projecoes = "Sim";
1584                     if("N".equals(indicador.getIndProjecaoIettr()))
1585                         projecoes = "Não";
1586                     //double total = 0;
1587                     String strTotal = "";
1588                     if("S".equals(indicador.getIndAcumulavelIettr())){
1589                         totalizacoes = "Sim";
1590                         //total = new ItemEstrtIndResulDao(null).getSomaQuantidades(indicador);
1591                         //strTotal = String.valueOf(total);
1592                     }   
1593                     else {
1594                     	if("M".equals(indicador.getIndValorFinalIettr()))
1595                     		valorFinal = "Maior";
1596                     	else if("U".equals(indicador.getIndValorFinalIettr()))
1597                     		valorFinal = "Último";
1598                     	else if("N".equals(indicador.getIndValorFinalIettr()))
1599                     		valorFinal = "Não se aplica";
1600                     	strTotal = new ItemEstrtIndResulDao(null).getSomaQuantidadePrevista(indicador);
1601                     	/*
1602                     	if(!"".equals(strTotal)){
1603                     		total = new Double(strTotal).doubleValue();
1604                     		strTotal = Util.formataMoeda(total);
1605                     	}
1606                     	*/
1607                     }
1608                     
1609                 	strTotal = new ItemEstrtIndResulDao(null).getSomaQuantidadePrevista(indicador);
1610                 	/*if(!"".equals(strTotal)){
1611                 		total = new Double(strTotal).doubleValue();
1612                 		strTotal = Util.formataNumeroSemDecimal(total);
1613                 	}*/
1614                                        
1615                     if("N".equals(indicador.getIndAcumulavelIettr())){                    
1616                         totalizacoes = "Não";                
1617                     }                    
1618                     builder.addNode("indicador",
1619                     		"nome=\"" + builder.normalize(Pagina.trocaNull(indicador.getNomeIettir())) + "\"" +
1620                     		" descricao=\"" + builder.normalize(Pagina.trocaNull(indicador.getDescricaoIettir())) + "\"" +
1621                     		" unidade=\"" + builder.normalize(Pagina.trocaNull(indicador.getUnidMedidaIettr())) + "\"" +
1622                     		" totalizacoes=\"" + builder.normalize(totalizacoes) + "\"" +
1623                     		" valorFinal=\"" + builder.normalize(valorFinal) + "\"" + 
1624                     		" projecoes=\"" + builder.normalize(projecoes) + "\"" +
1625                     		" total = \"" + builder.normalize(strTotal) + "\"");
1626                     
1627                     if(mostrarQuantidades){
1628                     	List exercicios = new ArrayList(indicador.getItemEstrutFisicoIettfs());
1629                     	
1630                     	Collections.sort(exercicios,
1631 							new Comparator() {
1632 				        		public int compare(Object o1, Object o2) {
1633 				        		    return ( (ItemEstrutFisicoIettf)o1 ).getExercicioExe().getDescricaoExe().compareToIgnoreCase( ( (ItemEstrutFisicoIettf)o2 ).getExercicioExe().getDescricaoExe() );
1634 				        		}
1635 				    		} );
1636                     	
1637 	                    //Iterator it = indicador.getItemEstrutFisicoIettfs().iterator();
1638 	                    Iterator it = exercicios.iterator();                
1639 	                    while(it.hasNext()){
1640 	                        ItemEstrutFisicoIettf exercicio = (ItemEstrutFisicoIettf) it.next();
1641 	                        builder.addClosedNode("exercicio", "descricao=\"" + builder.normalize(Pagina.trocaNull(exercicio.getExercicioExe().getDescricaoExe())) + "\" quantidade=\"" + Pagina.trocaNullNumeroSemDecimal(exercicio.getQtdPrevistaIettf().toString()) + "\"");
1642 	                    }
1643                     }
1644                     builder.closeNode("indicador");
1645                 }        
1646                 builder.closeNode("indicadoresResultado");                    
1647             }
1648         } catch(Exception e){
1649         	this.logger.error(e);
1650             throw new ECARException("Erro na criação do relatório: " + label);            
1651         }
1652     }    
1653     
1654       /**
1655        * Gera filhos xml.<br>
1656        * 
1657        * @author N/C
1658        * @since N/C
1659        * @version N/C
1660        * @param XmlBuilder builder
1661        * @param ItemEstruturaIett item
1662        * @param String tipoRelatorio
1663        * @param String orgao
1664        * @throws ECARException
1665        */
1666     public void geraXMLFilhos(XmlBuilder builder, ItemEstruturaIett item, String tipoRelatorio, String orgao) throws ECARException{
1667         try{
1668             Set descendentes = item.getItemEstruturaIetts();
1669             
1670             if(descendentes != null && descendentes.size() > 0){
1671                 Iterator it = descendentes.iterator();            
1672                 while(it.hasNext()){
1673                     ItemEstruturaIett itemFilho = (ItemEstruturaIett) it.next();
1674             
1675             		/* TODO: Remover esta validação quando terminar o processo do PPA.
1676             		 * 
1677             		 * "No relatório "Resumo", não exibir itens do nível de subproduto
1678             		 * Isto só será usando durante o processo PPA. Após este processo, essa verificação será retirada. 
1679             		 * Este comentário foi feito para facilitar a retirada deste código após o término do processo do PPA. 
1680             		 */
1681             		boolean exibirItem = true;
1682             		if("R".equals(tipoRelatorio)){
1683             			exibirItem = false;
1684             			if(itemFilho.getNivelIett() != null && itemFilho.getNivelIett().intValue() != 5){ //5 = Nível de Subproduto.
1685             				exibirItem = true;
1686             			}
1687             		}
1688             		
1689             		if(!"S".equals(contextoEcarPPA))
1690             			exibirItem = true;
1691                     
1692                     if(exibirItem){
1693 						String nomeNivelItem = builder.normalize(itemFilho.getEstruturaEtt().getNomeEtt()) + ": ";
1694 						
1695 						String nomeItem = " ";
1696 	
1697 						if(itemFilho.getSiglaIett() != null && !"".equals(itemFilho.getSiglaIett()))
1698 							nomeItem += itemFilho.getSiglaIett() + " - ";
1699 						
1700 						/* TODO: Remover esta validação quando terminar o processo do PPA.
1701 						 * 
1702 						 * Este if é referente ao item 4 do Mantis 5160:
1703 						 * "No relatório "Resumo", no nível da ação, Substituir o Nome da ação pelo Nome PPA"
1704 						 * Isto só será usando durante o processo PPA. Após este processo, essa verificação será retirada. 
1705 						 * Este comentário foi feito para facilitar a retirada deste código após o término do processo do PPA. 
1706 						 */
1707 						boolean buscarNomePPA = false;
1708 						if("R".equals(tipoRelatorio)){
1709 							if(itemFilho.getNivelIett() != null && (itemFilho.getNivelIett().intValue() == 3 || itemFilho.getNivelIett().intValue() == 4)){ //3 = Nível de Ação, 4 = Nível de Produto
1710 								buscarNomePPA = true;
1711 							}
1712 						}
1713 	
1714 						if(!"S".equals(contextoEcarPPA))
1715 							buscarNomePPA = false;
1716 						
1717 						if(buscarNomePPA)
1718 							nomeItem += builder.normalize(itemFilho.getDescricaoR3());
1719 						else
1720 							nomeItem += builder.normalize(itemFilho.getNomeIett());
1721 						
1722 	
1723 						builder.addNode("filho", "nomeNivel=\"" + builder.normalize(nomeNivelItem) + "\" nome=\"" + nomeItem + "\" " +
1724 	                                    " nivel=\"" + itemFilho.getNivelIett().intValue() + "\"");
1725 	
1726 						builder.closeNode("filho");
1727 						
1728 						this.incrementarTotalizador(itemFilho.getEstruturaEtt().getCodEtt(), nomeNivelItem);
1729 	
1730 	                    boolean mostrarDados = false;
1731 	                    
1732 	                    if("".equals(orgao) || orgao == null){ //Todos
1733 	                    	mostrarDados = true;
1734 	                    }
1735 	                    else if (orgao != null && itemFilho.getOrgaoOrgByCodOrgaoResponsavel1Iett() != null && orgao.equals(itemFilho.getOrgaoOrgByCodOrgaoResponsavel1Iett().getCodOrg().toString())){
1736 	                    	mostrarDados = true;
1737 	                    }
1738 	                    
1739 	                    if (!itensMarcados.contains(itemFilho.getCodIett().toString())){
1740 	                    	mostrarDados = false;
1741 	                    }
1742 	                    
1743 	                    if(mostrarDados){
1744 	                		geraXMLDadosBasicos(builder, itemFilho, tipoRelatorio);
1745 	                    
1746 	                		if("C".equals(tipoRelatorio)){
1747 	                			//geraXMLNiveisPlanejamento(builder, itemFilho);
1748 	                		}
1749 	                    
1750 	                    	geraXMLFuncoes(builder, itemFilho, tipoRelatorio, true);
1751 	                    }
1752 	                    geraXMLFilhos(builder, itemFilho, tipoRelatorio, orgao);
1753 	                    //builder.closeNode("filho");
1754 	                }   
1755             	}
1756             }            
1757         } catch(Exception e){
1758         	this.logger.error(e);
1759             throw new ECARException("Erro na criação do relatório: Listagem de Itens Filho");
1760         }            
1761     }
1762 
1763     /**
1764      * Gera filhos por orgao xml.<br>
1765      * 
1766      * @author N/C
1767      * @since N/C
1768      * @version N/C
1769      * @param XmlBuilder builder
1770      * @param ItemEstruturaIett item
1771      * @param String tipoRelatorio
1772      * @param String orgao
1773      * @param List listaCriteriosCom
1774      * @param List listaCriteriosSem
1775      * @param List listaSituacoes
1776      * @throws ECARException
1777      */
1778     public void geraXMLFilhosPorOrgao(XmlBuilder builder, ItemEstruturaIett item, String tipoRelatorio, 
1779     		String orgao, List listaCriteriosCom, List listaCriteriosSem, List listaSituacoes) throws ECARException{
1780         try{
1781         	UsuarioUsu usuarioLogado = seguranca.getUsuario();
1782         	Set gruposUsuario = seguranca.getGruposAcesso();        	
1783         	
1784             //Set filhos = item.getItemEstruturaIetts();
1785             ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(null);
1786             List filhos = new ArrayList();
1787             
1788             if(!imprimirEstrutura){
1789             	filhos.addAll(itemEstruturaDao.getDescendentesComPermissoesOrdenado(item, usuarioLogado, gruposUsuario));
1790             }
1791             else {
1792             	filhos.addAll(itemEstruturaDao.getDescendentesComPermissoesOrdenadoByEstrutura(estruturaEscolhida, codIettPai, usuarioLogado, gruposUsuario));
1793             }
1794         	
1795             String submitPPA = "";
1796             if("S".equals(contextoEcarPPA) && "R".equals(tipoRelatorio)){
1797             	submitPPA = "S";
1798             }
1799             List itensTemp = new ArrayList(itemEstruturaDao.filtrarRelatorioItemEstrutura(filhos, orgaoResponsavel.getCodOrg(), listaCriteriosCom, listaCriteriosSem, listaSituacoes, "N", submitPPA));
1800 
1801             filhos.clear();
1802         	//filhos.addAll(itemEstruturaDao.getArvoreItens(itensTemp, null));
1803         	filhos.addAll(itensTemp);
1804          
1805         	Iterator it;
1806         	
1807         	//remover os itens superiores ao nível atual
1808         	if(!imprimirEstrutura){
1809 	    		it = filhos.iterator();
1810 	    		while(it.hasNext()) {
1811 	    			ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
1812 	    			
1813 	    			if(iett.getNivelIett().intValue() <= item.getNivelIett().intValue()) {
1814 	    				it.remove();
1815 	    			}
1816 	    		}
1817         	}
1818         	
1819         	// ordenar os itens pela sigla
1820         	itensTemp = new ArrayList(filhos);
1821         	filhos.clear();
1822         	//filhos.addAll(itemEstruturaDao.getItensOrdenadosPorSiglaIett(itensTemp));
1823         	//filhos.addAll(itemEstruturaDao.getItensOrdenados(itensTemp));
1824         	List atributosListagem = new ArrayList(itemEstruturaDao.getItensOrdenados(itensTemp, null));
1825         	Iterator itAtrList = atributosListagem.iterator();
1826         	while(itAtrList.hasNext()){
1827         		AtributoEstruturaListagemItens atList = (AtributoEstruturaListagemItens) itAtrList.next();
1828         		filhos.add(atList.getItem());	
1829         	}
1830             
1831             //if(filhos != null && filhos.size() > 0){
1832         	if(atributosListagem != null && atributosListagem.size() > 0){
1833                 //it = filhos.iterator();
1834         		it = atributosListagem.iterator();
1835                 while(it.hasNext()){
1836                 	
1837                     //ItemEstruturaIett itemFilho = (ItemEstruturaIett) it.next();
1838                 	AtributoEstruturaListagemItens atbList = (AtributoEstruturaListagemItens) it.next();
1839                 	ItemEstruturaIett itemFilho = atbList.getItem();
1840                     
1841             		/* TODO: Remover esta validação quando terminar o processo do PPA.
1842             		 * 
1843             		 * "No relatório "Resumo", não exibir itens do nível de subproduto
1844             		 * Isto só será usando durante o processo PPA. Após este processo, essa verificação será retirada. 
1845             		 * Este comentário foi feito para facilitar a retirada deste código após o término do processo do PPA. 
1846             		 */
1847             		boolean exibirItem = true;
1848             		if("R".equals(tipoRelatorio)){
1849             			exibirItem = false;
1850             			if(itemFilho.getNivelIett() != null && itemFilho.getNivelIett().intValue() != 5){ //5 = Nível de Subproduto.
1851             				exibirItem = true;
1852             			}
1853             		}
1854             		
1855             		if(!"S".equals(contextoEcarPPA))
1856             			exibirItem = true;
1857             		
1858                 	if(exibirItem){
1859                     
1860 						String nomeNivelItem = builder.normalize(itemFilho.getEstruturaEtt().getNomeEtt()) + ": ";
1861 						String nomeItem = " ";
1862 						String itemSelecionado = "S";
1863 	
1864 						if(itemFilho.getSiglaIett() != null && !"".equals(itemFilho.getSiglaIett()))
1865 							nomeItem += itemFilho.getSiglaIett() + " - ";
1866 						
1867 						/* TODO: Remover esta validação quando terminar o processo do PPA.
1868 						 * 
1869 						 * Este if é referente ao item 4 do Mantis 5160:
1870 						 * "No relatório "Resumo", no nível da ação, Substituir o Nome da ação pelo Nome PPA"
1871 						 * Isto só será usando durante o processo PPA. Após este processo, essa verificação será retirada. 
1872 						 * Este comentário foi feito para facilitar a retirada deste código após o término do processo do PPA. 
1873 						 */
1874 						boolean buscarNomePPA = false;
1875 						if("R".equals(tipoRelatorio)){
1876 							if(itemFilho.getNivelIett() != null && (itemFilho.getNivelIett().intValue() == 3 || itemFilho.getNivelIett().intValue() == 4)){ //3 = Nível de Ação, 4 = Nível de Produto
1877 								buscarNomePPA = true;
1878 							}
1879 						}
1880 	
1881 						if(!"S".equals(contextoEcarPPA))
1882 							buscarNomePPA = false;
1883 						
1884 						if(buscarNomePPA)
1885 							nomeItem += builder.normalize(itemFilho.getDescricaoR3());
1886 						else{
1887 							//nomeItem += builder.normalize(itemFilho.getNomeIett());
1888 							nomeItem = builder.normalize(" " + ("".equals(atbList.getDescricao().trim()) ? itemFilho.getNomeIett() : atbList.getDescricao()));
1889 						}
1890 						
1891 						if (!itensMarcados.contains(itemFilho.getCodIett().toString()))
1892 							itemSelecionado = "N";
1893 						
1894 						builder.addNode("filho", "nomeNivel=\"" + builder.normalize(nomeNivelItem) + "\" nome=\"" + nomeItem + "\" " +
1895 	                                    " nivel=\"" + itemFilho.getNivelIett().intValue() + "\"" +
1896 	                                    " itemSelecionado=\"" + builder.normalize(itemSelecionado) + "\"");
1897 	
1898 						builder.closeNode("filho");
1899 	
1900 						this.incrementarTotalizador(itemFilho.getEstruturaEtt().getCodEtt(), nomeNivelItem);
1901 						
1902 	                    boolean mostrarDados = false;
1903 	                    
1904 	                    if("".equals(orgao) || orgao == null){ //Todos
1905 	                    	mostrarDados = true;
1906 	                    }
1907 	                    else if (orgao != null && itemFilho.getOrgaoOrgByCodOrgaoResponsavel1Iett() != null && orgao.equals(itemFilho.getOrgaoOrgByCodOrgaoResponsavel1Iett().getCodOrg().toString())){
1908 	                    	mostrarDados = true;
1909 	                    }
1910 	                    
1911 	                    if (!itensMarcados.contains(itemFilho.getCodIett().toString())){
1912 	                    	mostrarDados = false;
1913 	                    }
1914 	                    
1915 	                    if(mostrarDados){
1916 	                		geraXMLDadosBasicos(builder, itemFilho, tipoRelatorio);
1917 	                    
1918 	                		if("C".equals(tipoRelatorio)){
1919 	                			//geraXMLNiveisPlanejamento(builder, itemFilho);
1920 	                		}
1921 	                    
1922 	                    	geraXMLFuncoes(builder, itemFilho, tipoRelatorio, true);
1923 	                    }
1924 	                }  
1925                 }
1926             }            
1927         } catch(Exception e){
1928         	this.logger.error(e);
1929             throw new ECARException("Erro na criação do relatório: Listagem de Itens Filho");
1930         }            
1931     }
1932 
1933     /**
1934      * Gera totalizador xml.<br>
1935      * 
1936      * @author N/C
1937      * @since N/C
1938      * @version N/C
1939      * @param XmlBuilder builder
1940      * @throws ECARException
1941      */
1942     public void geraXMLTotalizador(XmlBuilder builder) throws ECARException{
1943         try{
1944         	int total = 0;
1945         	builder.addNode("totalizadores");        	
1946             Iterator itTotalizadores = totalizadores.iterator();
1947             while(itTotalizadores.hasNext()){
1948             	TotalizadorRelatorios tr = (TotalizadorRelatorios) itTotalizadores.next();
1949             	String nome = tr.getEstrutura();
1950             	String valor = "" + tr.getTotal();
1951             	total += tr.getTotal();
1952             	builder.addClosedNode("totalizador",
1953             			"nome=\"" + builder.normalize(nome) + "\"" +
1954             			" valor=\"" + builder.normalize(valor) + "\"");
1955             }        	
1956         	builder.addClosedNode("total", 
1957         			"nome=\"Total:\"" +
1958         			" valor=\"" + builder.normalize(String.valueOf(total)) + "\"");
1959             builder.closeNode("totalizadores");
1960         } catch(Exception e){
1961         	this.logger.error(e);
1962             throw new ECARException("Erro na criação do relatório: Totalizadores");
1963         }            
1964     }
1965 
1966     /**
1967      * Descobre tipo.<br>
1968      * 
1969      * @author N/C
1970      * @since N/C
1971      * @version N/C
1972      * @param String nomeAtb
1973      * @return String
1974      */
1975     private String descobreTipo(String nomeAtb) {
1976         
1977         if("objetivoGeralIett".equals(nomeAtb) 
1978            || "objetivoEspecificoIett".equals(nomeAtb)
1979            || "beneficiosIett".equals(nomeAtb)
1980            || "descricaoIett".equals(nomeAtb)
1981            || "descricaoR1".equals(nomeAtb)
1982            || "descricaoR2".equals(nomeAtb)
1983            || "descricaoR3".equals(nomeAtb)
1984            || "descricaoR4".equals(nomeAtb)
1985            || "descricaoR5".equals(nomeAtb)
1986         )
1987             return "atributo2";
1988         else
1989             return "atributo1";
1990     }
1991 
1992     /**
1993      * Pega o nome do arquivo xsl.<br>
1994      * 
1995      * @author N/C
1996      * @since N/C
1997      * @version N/C
1998      * @return String
1999      */
2000     public String getXslFileName() {
2001         return "itemEstrutura.xsl";
2002     }
2003     
2004     /**
2005      * Retorna pagina de erro.<br>
2006      * 
2007      * @author N/C
2008      * @since N/C
2009      * @version N/C
2010      * @param HttpServletRequest request
2011      * @param String mensagem
2012      * @return String
2013      */
2014     public String getErrorPage(HttpServletRequest request, String mensagem){        
2015         String errorPage = "frm_rel.jsp?codIett=" + Pagina.getParamStr(request, "codIett") + "&msgOperacao=" + mensagem + "&codAba="+Pagina.getParamStr(request, "codAba"); 
2016         return errorPage;
2017     }
2018 
2019     /**
2020      * Busca Funcao Pai.<br>
2021      * 
2022      * @author N/C
2023      * @since N/C
2024      * @version N/C
2025      * @param ItemEstruturaIett item
2026      * @param Long codigo
2027      * @return EstruturaFuncaoEttf
2028      * @throws ECARException
2029      */
2030     private EstruturaFuncaoEttf buscarFuncaoPai(ItemEstruturaIett item, Long codigo) throws ECARException {
2031     	try {
2032     		EstruturaFuncaoDao estruturaFuncaoDao = new EstruturaFuncaoDao(null);
2033 			
2034 			EstruturaFuncaoEttfPK chave = new EstruturaFuncaoEttfPK();
2035 			chave.setCodEtt(item.getEstruturaEtt().getCodEtt());
2036 			chave.setCodFun(codigo);
2037 			EstruturaFuncaoEttf funcaoPai = (EstruturaFuncaoEttf) estruturaFuncaoDao.buscar(EstruturaFuncaoEttf.class, chave);
2038 			
2039 			return funcaoPai;
2040     	} catch (Exception e) {
2041     		return null;
2042     	}
2043     }
2044     
2045     /**
2046      * Verifica funcao.<br>
2047      * 
2048      * @author N/C
2049      * @since N/C
2050      * @version N/C
2051      * @param String funcao
2052      * @param List funcoes
2053      * @param String tipoRelatorio
2054      * @return boolean
2055      */
2056     private boolean verificarFuncao(String funcao, List funcoes, String tipoRelatorio){
2057 		Iterator itFuncoes = funcoes.iterator();
2058 		boolean retorno = false;
2059 		while(itFuncoes.hasNext()){
2060 			EstruturaFuncaoEttf funcaoParalela = (EstruturaFuncaoEttf) itFuncoes.next();
2061 			if(funcao.equals(funcaoParalela.getFuncaoFun().getNomeFun())){
2062 
2063 				if("S".equals(funcaoParalela.getIndListagemImpressaResEttf()) && "R".equals(tipoRelatorio)){
2064 					retorno = true;
2065 	                break;
2066                 }
2067                 if("S".equals(funcaoParalela.getIndListagemImpressCompEttf()) && "C".equals(tipoRelatorio)){
2068                 	retorno = true;
2069 	                break;
2070                 }
2071 			}
2072 		}
2073     	return retorno;
2074     }
2075     
2076     /**
2077      * Incrementa Totalizador.<br>
2078      * 
2079      * @author N/C
2080      * @since N/C
2081      * @version N/C
2082      * @param Long idEstrutura
2083      * @param String nomeEstrutura
2084      */
2085     private void incrementarTotalizador(Long idEstrutura, String nomeEstrutura){
2086     	if(!idsEstrutura.contains(idEstrutura)){
2087     		TotalizadorRelatorios totalizador = new TotalizadorRelatorios();
2088     		totalizador.setId(idEstrutura);
2089     		totalizador.setEstrutura(nomeEstrutura);
2090     		totalizador.setTotal(1);
2091     		
2092     		idsEstrutura.add(idEstrutura);
2093     		totalizadores.add(totalizador);
2094     	}
2095     	else {
2096     		Iterator itTotalizadores = totalizadores.iterator();
2097     		while(itTotalizadores.hasNext()){
2098     	   		TotalizadorRelatorios totalizador = (TotalizadorRelatorios) itTotalizadores.next();
2099     	   	    
2100     	   		if(idEstrutura.equals(totalizador.getId())){
2101     	   			totalizador.incrementeTotal();
2102     	   			break;
2103     	   	    }
2104     		}
2105     	}
2106     }
2107 }