RevisaoItemEstruturaMetasFisicas xref

View Javadoc

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