ExportacaoRelatorioItemEstruturaDao xref

View Javadoc

1   package ecar.dao;
2   
3   import java.io.File;
4   import java.io.FileOutputStream;
5   import java.util.ArrayList;
6   import java.util.Date;
7   import java.util.Iterator;
8   import java.util.List;
9   import java.util.Set;
10  import java.util.Map;
11  import java.util.HashMap;
12  import java.util.Collection;
13  import javax.servlet.http.HttpServletRequest;
14  
15  import org.apache.log4j.Logger;
16  
17  import comum.database.Dao;
18  import comum.util.Data;
19  import comum.util.Pagina;
20  import comum.util.Util;
21  import ecar.exception.ECARException;
22  import ecar.pojo.AtributoLivre;
23  import ecar.pojo.ConfiguracaoCfg;
24  import ecar.pojo.DemAtributoDema;
25  import ecar.pojo.EstrutTpFuncAcmpEtttfa;
26  import ecar.pojo.EstruturaEtt;
27  import ecar.pojo.ItemEstruturaIett;
28  import ecar.pojo.ItemEstruturaSisAtributoIettSatb;
29  import ecar.pojo.ObjetoDemanda;
30  import ecar.pojo.ObjetoEstrutura;
31  import ecar.pojo.RegDemandaRegd;
32  import ecar.pojo.SisAtributoSatb;
33  import ecar.pojo.AcompReferenciaAref;
34  import ecar.pojo.SisGrupoAtributoSga;
35  import ecar.pojo.SituacaoSit;
36  import ecar.pojo.StatusRelatorioSrl;
37  import ecar.pojo.TipoFuncAcompTpfa;
38  import ecar.login.SegurancaECAR;
39  import ecar.pojo.AcompReferenciaItemAri;
40  import ecar.pojo.AcompRelatorioArel;
41  import ecar.pojo.UsuarioUsu;
42  import ecar.pojo.UsuarioAtributoUsua;
43  import ecar.pojo.TipoAcompanhamentoTa;
44  import ecar.pojo.OrgaoOrg;
45  import ecar.bean.AtributoEstruturaListagemItens;
46  import ecar.permissao.ValidaPermissao;
47  import ecar.util.Dominios;
48  
49  public class ExportacaoRelatorioItemEstruturaDao extends Dao {
50  
51    private String separadorCampos;
52    private String separadorMultivalor;
53  
54    /**
55     * Construtor. Chama o Session factory do Hibernate
56     */
57    public ExportacaoRelatorioItemEstruturaDao(HttpServletRequest request) {
58      super();
59      this.request = request;
60    }
61  
62    /**
63     * Gera o arquivo de exportação
64     * @param nomeArquivo
65     * @param configuracao
66     * @return List de String[], onde: posicao 0 --> caminho do arquivo gravado no
67     *         servidor posicao 1 --> nome do arquivo gerado
68     * @throws ECARException
69     */
70    public List gerarArquivosExportacaoTxt(List<EstruturaEtt> listaEstruturas, ConfiguracaoCfg configuracao, ItemEstruturaIett itemPrincipal) throws ECARException {
71  
72      this.separadorCampos = configuracao.getSeparadorArqTXT();
73      this.separadorMultivalor = configuracao.getSeparadorCampoMultivalor();
74  
75      ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(null);
76      EstruturaDao estruturaDao = new EstruturaDao(null);
77  
78      // configuração de upload
79      String caminho = configuracao.getRaizUpload() + configuracao.getUploadExportacaoDemandas();
80      // indica que o relatorio a ser montado é gerado a partir de cadastro
81      String relatorioTipoMonitoramento = "N";
82  
83      ItemEstruturaIett item = new ItemEstruturaIett();
84      List retorno = new ArrayList();
85  
86      if (!caminho.endsWith("/"))
87        caminho = caminho + "/";
88  
89      try {
90  
91        Iterator itEstruturas = listaEstruturas.iterator();
92        EstruturaEtt estruturaCorrente;
93        List itensEstruturaCorrente = new ArrayList();
94        List itensPais = new ArrayList();
95        List listEstruturasGeral = new ArrayList();
96  
97        int sequencialItensPai = 1;
98        int sequencialItemPaiAtual = 1;
99        int sequencialEstrutura = 1;
100 
101       Date dataInicio = Data.getDataAtual();
102 
103       // gera uma lista com as estruturas filhas da estrutura selecionada
104       while (itEstruturas.hasNext()) {
105 
106         estruturaCorrente = (EstruturaEtt) itEstruturas.next();
107 
108         // adiciona a estrutura à lista de exportação caso a mesma esteja ativa
109         if (estruturaCorrente.getIndAtivoEtt().equals("S")) {
110           listEstruturasGeral.add(estruturaCorrente);
111         }
112 
113         // Re-consultar a estrutura para resolver exceção de
114         // LazyInitializationException
115         estruturaCorrente = (EstruturaEtt) estruturaDao.buscar(EstruturaEtt.class, estruturaCorrente.getCodEtt());
116 
117         if (estruturaCorrente.getEstruturaEtts() != null && !estruturaCorrente.getEstruturaEtts().isEmpty()) {
118 
119           listEstruturasGeral.addAll(getEstruturasFilhas(estruturaCorrente));
120 
121         }
122       }
123 
124       Iterator itEstruturasGeral = listEstruturasGeral.iterator();
125 
126       Date dataInicioItens = Data.getDataAtual();
127 
128       while (itEstruturasGeral.hasNext()) {
129 
130         int sequencialItens = 1;
131         sequencialItensPai = 1;
132 
133         estruturaCorrente = (EstruturaEtt) itEstruturasGeral.next();
134 
135         // Cria um arquivo para cada estrutura
136         String caminhoCompleto = "";
137 
138         // Cria o nome do arquivo -> <ID Sequencial>_<Nome da Estrutura
139         // Pai>_<Nome da Estrutura Utilizada>.txt
140         String nomeArquivo = String.valueOf(sequencialEstrutura);
141         if (estruturaCorrente.getEstruturaEtt() != null) {
142           if (!estruturaCorrente.getEstruturaEtt().getNomeEtt().equals(""))
143             nomeArquivo += "_" + estruturaCorrente.getEstruturaEtt().getNomeEtt();
144           else
145             nomeArquivo += "_" + estruturaCorrente.getEstruturaEtt().getLabelEtt();
146         }
147         if (!estruturaCorrente.getNomeEtt().equals(""))
148           nomeArquivo += "_" + estruturaCorrente.getNomeEtt();
149         else
150           nomeArquivo += "_" + estruturaCorrente.getLabelEtt();
151         nomeArquivo += ".txt";
152 
153         nomeArquivo = nomeArquivo.replaceAll("/", "-");
154 
155         sequencialEstrutura++;
156 
157         caminhoCompleto = caminho + nomeArquivo;
158 
159         String[] caminhoArquivo = { caminhoCompleto, nomeArquivo };
160         retorno.add(caminhoArquivo);
161 
162         File diretorio = new File(caminho);
163 
164         if (!diretorio.isDirectory())
165           diretorio.mkdirs();
166 
167         FileOutputStream arquivo = new FileOutputStream(caminhoCompleto);
168 
169         // Re-consultar a estrutura para resolver exceção de
170         // LazyInitializationException
171         estruturaCorrente = (EstruturaEtt) estruturaDao.buscar(EstruturaEtt.class, estruturaCorrente.getCodEtt());
172         List<ObjetoEstrutura> atributosOrdenados = estruturaDao.getAtributosEstruturaDadosGerais(estruturaCorrente);
173         Iterator<ObjetoEstrutura> atributosOrdenadosIt = atributosOrdenados.iterator();
174 
175         String linha = montaLinhaCabecalhoEstrutura(atributosOrdenadosIt, estruturaCorrente, relatorioTipoMonitoramento);
176 
177         List listItensPorEstrutura;
178 
179         if (itemPrincipal != null) {
180           List codPossiveisItensPais = montarListaCodigosPais(itemPrincipal);
181           listItensPorEstrutura = itemEstruturaDao.getItensByEstruturaOrdenadosPorItemPai(estruturaCorrente.getCodEtt(), codPossiveisItensPais);
182         }
183         else {
184           // se passar por aqui é porque nao possui nenhum item selecionado
185           listItensPorEstrutura = itemEstruturaDao.getItensByEstrutura(estruturaCorrente.getCodEtt());
186         }
187 
188         if (listItensPorEstrutura != null && !listItensPorEstrutura.isEmpty() && atributosOrdenados != null && !atributosOrdenados.isEmpty()) {
189 
190           Iterator<ItemEstruturaIett> listItensPorEstruturaIt = listItensPorEstrutura.iterator();
191           ItemEstruturaIett itemEstruturaPaiCorrente = null;
192           int contItens = 0;
193 
194           // Para cada item de estrutura criar a linhas com os campos da
195           // estrutura correspondente
196           while (listItensPorEstruturaIt.hasNext()) {
197 
198             atributosOrdenadosIt = atributosOrdenados.iterator();
199             ItemEstruturaIett itemEstruturaCorrente = (ItemEstruturaIett) listItensPorEstruturaIt.next();
200 
201             // Verifica se o usuário tem acesso ao item
202             ValidaPermissao validaPermissao = new ValidaPermissao();
203             SegurancaECAR seguranca = (SegurancaECAR) request.getSession().getAttribute("seguranca");
204 
205             boolean permissaoAcessoItem = validaPermissao.permissaoConsultarItem(itemEstruturaCorrente, seguranca.getUsuario(), seguranca.getGruposAcesso()) || validaPermissao.permissaoExcluirItem(itemEstruturaCorrente, seguranca.getUsuario(), seguranca.getGruposAcesso());
206             boolean permissaoAcessoItensFilhos = false;
207 
208             /*
209              * hint de otimização. Só testa se tem permissão para os filhos
210              * (recursivo) se não tiver para si próprio
211              */
212             if (!permissaoAcessoItem) {
213               permissaoAcessoItensFilhos = validaPermissao.permissaoAcessoItensFilhos(itemEstruturaCorrente, seguranca.getUsuario(), seguranca.getGruposAcesso());
214             }
215 
216             if (permissaoAcessoItem || permissaoAcessoItensFilhos) {
217 
218               // Se for o primeiro item o item pai passa a ser o pai desse item
219               if (itemEstruturaPaiCorrente == null && itemEstruturaCorrente.getItemEstruturaIett() != null) {
220                 itemEstruturaPaiCorrente = itemEstruturaCorrente.getItemEstruturaIett();
221                 sequencialItemPaiAtual = verificaSequencialPai(itemEstruturaCorrente, itensPais);
222               }
223 
224               // Se o próximo item tiver um item pai diferente do anterior, o
225               // sequencial de itens pais é
226               // incrementado e um novo item pai corrente é atribuido
227               if (itemEstruturaPaiCorrente != null && !itemEstruturaPaiCorrente.equals(itemEstruturaCorrente.getItemEstruturaIett())) {
228 
229                 sequencialItemPaiAtual = verificaSequencialPai(itemEstruturaCorrente, itensPais);
230                 itemEstruturaPaiCorrente = itemEstruturaCorrente.getItemEstruturaIett();
231               }
232 
233               int[] pai = { itemEstruturaCorrente.getCodIett().intValue(), sequencialItensPai };
234               itensPais.add(pai);
235               sequencialItensPai++;
236 
237               // Consulta o itemEstrutura pois quando vai pegar a coleção de
238               // atributos livres dá erro de hibernate (lazy)
239               itemEstruturaCorrente = (ItemEstruturaIett) itemEstruturaDao.buscar(ItemEstruturaIett.class, itemEstruturaCorrente.getCodIett());
240 
241               /*
242                * Para cada item escreve uma linha:
243                * <campo1>[separador]<campo2>[separador]<campo3>...[quebra de
244                * linha] Campo deve estar na mesma ordem que está sendo exibida
245                * na tela de cadastro --> atributosOrdenados
246                */
247 
248               linha += montaLinhaItemEstruturaComCamposOrdenados(atributosOrdenadosIt, itemEstruturaCorrente, sequencialItemPaiAtual, sequencialItens, "N", configuracao, null);
249 
250               sequencialItens++;
251             }
252           }
253         }
254 
255         // escreve linha no arquivo .txt
256         linha = Util.normalizaCaracterMarcador(linha);
257         arquivo.write(linha.getBytes());
258         arquivo.flush();
259 
260       }
261 
262       Date dataFim = Data.getDataAtual();
263 
264       long df = dataFim.getTime();
265       long di = dataInicio.getTime();
266 
267       System.out.println("Tempo de processamento dos loops: " + Data.parseDateHourSegundos(new Date(df - di)));
268     } catch (Exception e) {
269       Logger logger = Logger.getLogger(this.getClass());
270       logger.error(e);
271     }
272 
273     return retorno;
274   }
275 
276   /**
277    * Método que busca o sequencial do item do pai na lista de pais formada por
278    * (codIett, sequencial) com todos os itens de estrutura
279    * @param itemEstruturaCorrente
280    * @param itensPais
281    * @return int
282    */
283   private int verificaSequencialPai(ItemEstruturaIett itemEstruturaCorrente, List itensPais) {
284     int sequencial = 0;
285 
286     for (int i = 0; i < itensPais.size(); i++) {
287       int[] pai = (int[]) itensPais.get(i);
288       // int[] pai =
289       // {itemEstruturaCorrente.getCodIett().intValue(),sequencialItensPai};
290       if (pai[0] == itemEstruturaCorrente.getItemEstruturaIett().getCodIett().intValue()) {
291         sequencial = pai[1];
292         break;
293       }
294     }
295 
296     return sequencial;
297   }
298 
299   // DAVI
300   private List<Long> montarListaCodigosPais(ItemEstruturaIett itemPai) {
301 
302     List<Long> possiveisItensPais = new ArrayList<Long>();
303 
304     possiveisItensPais.add(itemPai.getCodIett());
305 
306     if (itemPai.getItemEstruturaIetts() != null && itemPai.getItemEstruturaIetts().size() > 0) {
307 
308       Iterator<ItemEstruturaIett> itensFilhosIt = itemPai.getItemEstruturaIetts().iterator();
309 
310       while (itensFilhosIt.hasNext()) {
311 
312         possiveisItensPais.addAll(montarListaCodigosPais((ItemEstruturaIett) itensFilhosIt.next()));
313       }
314     }
315 
316     return possiveisItensPais;
317   }
318 
319   private String montaLinhaCabecalhoEstrutura(Iterator<ObjetoEstrutura> atributosOrdenadosIt, EstruturaEtt estruturaCorrente, String relatorioTipoMonitoramento) throws ECARException {
320 
321     String linhaRetorno = "";
322 
323     try {
324 
325       // se for relatorio a partir de cadastro adiciona o nome dos itens
326       if (relatorioTipoMonitoramento.equals("N")) {
327         if (estruturaCorrente.getEstruturaEtt() != null) {
328           linhaRetorno += "ID_" + estruturaCorrente.getEstruturaEtt().getNomeEtt().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
329           // definir separador
330           linhaRetorno += this.separadorCampos;
331         }
332         else {
333           linhaRetorno += this.separadorCampos;
334         }
335 
336         linhaRetorno += "ID_" + estruturaCorrente.getNomeEtt().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
337         linhaRetorno += this.separadorCampos;
338       }
339 
340       while (atributosOrdenadosIt.hasNext()) {
341         ObjetoEstrutura atributo = (ObjetoEstrutura) atributosOrdenadosIt.next();
342 
343         if (atributo.iGetIndOpcional() == null || atributo.iGetIndOpcional().booleanValue() == false) {
344           // Mantis 6514: para atributos não opcionais verificar pelo campo
345           // "sequencia de apresentacao em telas de informaï¿½ï¿½o"
346           if (atributo.iGetSequenciaCampoEmTela() != null && atributo.iGetSequenciaCampoEmTela().intValue() != 0) {
347             if (atributo.iGetLabel() != null && !"".equals(atributo.iGetLabel())) {
348               linhaRetorno += atributo.iGetLabel().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
349             }
350             else {
351               linhaRetorno += atributo.iGetNome().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
352             }
353 
354             // escreve o separador entre cada campo
355             linhaRetorno += this.separadorCampos;
356           }
357         }
358         else if (atributo.iGetNome().equals("nivelPlanejamento")) {
359           SisGrupoAtributoSga grupoAtributo = new ConfiguracaoDao(null).getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan();
360           linhaRetorno += grupoAtributo.getDescricaoSga().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
361           linhaRetorno += this.separadorCampos;
362 
363         }
364         else {
365 
366           if (atributo.iGetLabel() != null && !"".equals(atributo.iGetLabel())) {
367             linhaRetorno += atributo.iGetLabel().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
368           }
369           else {
370             linhaRetorno += atributo.iGetNome().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
371           }
372 
373           // escreve o separador entre cada campo
374           linhaRetorno += this.separadorCampos;
375         }
376 
377       }
378 
379       // escreve o fim da linha com quebra de linha
380       if (!linhaRetorno.equals("")) {
381 
382         linhaRetorno = linhaRetorno.replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
383 
384         // Quebra de Linha
385         linhaRetorno += "\n";
386       }
387 
388     } catch (Exception e) {
389       Logger logger = Logger.getLogger(this.getClass());
390       logger.error(e);
391     }
392 
393     return linhaRetorno;
394   }
395 
396   /**
397    * Método que monta a linha com os campos de item ordenados. A linha deve
398    * seguir o padrão: <campo1>[separador]<campo2>[separador]<campo3>...[quebra
399    * de linha]
400    * @param atributosOrdenadosIt
401    * @param itemEstruturaIett
402    * @return linha
403    */
404   private String montaLinhaItemEstruturaComCamposOrdenados(Iterator<ObjetoEstrutura> atributosOrdenadosIt, ItemEstruturaIett itemEstruturaIett, int sequencialItensPai, int sequencialItens, String relatorioTipoMonitoramento, ConfiguracaoCfg configuracao, AcompReferenciaAref acompReferenciaAref) {
405 
406     String linhaRetorno = "";
407 
408     boolean itemPertenceAref = verificarItemPertenceAref(itemEstruturaIett, acompReferenciaAref);
409     if (atributosOrdenadosIt != null) {
410 
411       // Se nao for do tipo monitoramento, adiciona os sequenciais
412       if (relatorioTipoMonitoramento.equals("N")) {
413 
414         // Campo sequencial de itens pais
415         if (itemEstruturaIett.getItemEstruturaIett() != null) {
416           linhaRetorno += sequencialItensPai;
417         }
418         // definir separador
419         linhaRetorno += this.separadorCampos;
420 
421         // campo sequencial do item corrente
422         linhaRetorno += sequencialItens;
423         linhaRetorno += this.separadorCampos;
424       }
425 
426       while (atributosOrdenadosIt.hasNext()) {
427         ObjetoEstrutura atributo = (ObjetoEstrutura) atributosOrdenadosIt.next();
428 
429         try {
430 
431           // Se for atributo livre pega valor pelo
432           // ItemEstruturaSisAtributoIettSatbs
433           if (atributo.iGetGrupoAtributosLivres() != null && (atributo.iGetGrupoAtributosLivres().getIndAtivoSga() != null && atributo.iGetGrupoAtributosLivres().getIndAtivoSga().equals("S"))) {
434 
435             if (itemEstruturaIett.getItemEstruturaSisAtributoIettSatbs() != null) {
436               String separadorParaCamposMulti = "";
437               String separadorParaCamposCheck = "";
438               // Iterador com os atributos livres do ítem em questao
439               Iterator<ItemEstruturaSisAtributoIettSatb> itAtribLivres = itemEstruturaIett.getItemEstruturaSisAtributoIettSatbs().iterator();
440 
441               // Para cada atributo livre do ítem, verifica-se se este
442               // corresponde
443               // ao atributo que esta sendo tratado
444               while (itAtribLivres.hasNext()) {
445 
446                 ItemEstruturaSisAtributoIettSatb itemEstruturaSisAtrib = (ItemEstruturaSisAtributoIettSatb) itAtribLivres.next();
447                 // Iterador com os atributos livres associados ao atributo em
448                 // questão
449                 Iterator<SisAtributoSatb> sisAtributosSatbIt = atributo.iGetGrupoAtributosLivres().getSisAtributoSatbs().iterator();
450 
451                 while (sisAtributosSatbIt.hasNext()) {
452                   SisAtributoSatb sisAtributo = (SisAtributoSatb) sisAtributosSatbIt.next();
453                   if ((sisAtributo).equals(itemEstruturaSisAtrib.getSisAtributoSatb())) {
454                     // Caso seja um atributo tipo texto
455                     if (itemEstruturaSisAtrib.getInformacaoIettSatb() != null) {
456                       if (itemPertenceAref || relatorioTipoMonitoramento.equals(Pagina.NAO)) {
457                         linhaRetorno += separadorParaCamposMulti + itemEstruturaSisAtrib.getInformacaoIettSatb().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
458                         separadorParaCamposMulti = this.separadorMultivalor;
459                       }
460 
461                       // Caso seja atributo tipo check, radio ou select
462                     }
463                     else if (itemEstruturaSisAtrib.getSisAtributoSatb().getDescricaoSatb() != null) {
464                       if (itemPertenceAref || relatorioTipoMonitoramento.equals(Pagina.NAO)) {
465                         linhaRetorno += separadorParaCamposCheck + (itemEstruturaSisAtrib.getSisAtributoSatb().getDescricaoSatb()).replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
466                         ;
467                         separadorParaCamposCheck = this.separadorMultivalor;
468                       }
469 
470                       // Caso não tenha valor associado ao atributo
471                     }
472                     else {
473                       linhaRetorno += "";
474                     }
475                   }
476                 }
477               }
478               separadorParaCamposMulti = "";
479               separadorParaCamposCheck = "";
480               linhaRetorno += this.separadorCampos;
481             }
482 
483           }
484           else if (atributo.iGetNome().equals("situacaoSit")) {
485             if (itemPertenceAref || relatorioTipoMonitoramento.equals(Pagina.NAO)) {
486               String nomeAtributo = "";
487               List situacoes = new SituacaoDao(null).getSituacaoByEstrutura(itemEstruturaIett.getEstruturaEtt(), new String[] { "descricaoSit", "asc" });
488               Iterator it = situacoes.iterator();
489               while (it.hasNext() && nomeAtributo.equals("")) {
490                 SituacaoSit situacao = (SituacaoSit) it.next();
491                 if (situacao != null && itemEstruturaIett.getSituacaoSit() != null && situacao.getDescricaoSit().equals(itemEstruturaIett.getSituacaoSit().getDescricaoSit())) {
492                   nomeAtributo = situacao.getDescricaoSit();
493                 }
494               }
495 
496               if (!nomeAtributo.equals(""))
497                 linhaRetorno += nomeAtributo.replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
498             }
499 
500             linhaRetorno += this.separadorCampos;
501 
502           }
503           else if (atributo.iGetNome().equals("nivelPlanejamento")) {
504 
505             if (itemPertenceAref || relatorioTipoMonitoramento.equals(Pagina.NAO)) {
506               if (itemEstruturaIett.getItemEstruturaNivelIettns() != null && !itemEstruturaIett.getItemEstruturaNivelIettns().isEmpty()) {
507                 Iterator itNiveis = itemEstruturaIett.getItemEstruturaNivelIettns().iterator();
508                 while (itNiveis.hasNext()) {
509                   SisAtributoSatb nivel = (SisAtributoSatb) itNiveis.next();
510                   linhaRetorno += nivel.getDescricaoSatb().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
511                 }
512               }
513             }
514             linhaRetorno += this.separadorCampos;
515           }
516           else {
517 
518             if (atributo.iGetIndOpcional() == null || atributo.iGetIndOpcional().booleanValue() == false) {
519               // Mantis 6514: para atributos nï¿½o opcionais verificar pelo
520               // campo "sequencia de apresentacao em telas de informaï¿½ï¿½o"
521               if (atributo.iGetSequenciaCampoEmTela() != null && atributo.iGetSequenciaCampoEmTela().intValue() != 0) {
522                 // Se for campo fixo pega valor direto do atributo
523                 if (itemPertenceAref || relatorioTipoMonitoramento.equals(Pagina.NAO)) {
524                   linhaRetorno += Pagina.trocaNull(atributo.iGetValor(itemEstruturaIett)).replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
525                 }
526                 linhaRetorno += this.separadorCampos;
527               }
528             }
529             else {
530               // Se for campo fixo pega valor direto do atributo
531               if (itemPertenceAref || relatorioTipoMonitoramento.equals(Pagina.NAO)) {
532                 linhaRetorno += Pagina.trocaNull(atributo.iGetValor(itemEstruturaIett)).replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
533               }
534               linhaRetorno += this.separadorCampos;
535             }
536           }
537 
538         } catch (ECARException e) {
539           Logger logger = Logger.getLogger(this.getClass());
540           logger.error(e);
541         }
542       }
543 
544       // escreve o fim da linha com quebra de linha
545       if (!linhaRetorno.equals("")) {
546 
547         linhaRetorno = linhaRetorno.replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
548 
549         // Quebra de Linha
550         linhaRetorno += "\n";
551       }
552     }
553 
554     return linhaRetorno;
555   }
556 
557   private List getEstruturasFilhas(EstruturaEtt estrutura) throws ECARException {
558 
559     List retorno = new ArrayList();
560 
561     Iterator itEstruturaFilha = estrutura.getEstruturaEtts().iterator();
562 
563     while (itEstruturaFilha.hasNext()) {
564 
565       EstruturaEtt estruturaFilha = (EstruturaEtt) itEstruturaFilha.next();
566 
567       if (estruturaFilha.getIndAtivoEtt().equals("S")) {
568         retorno.add(estruturaFilha);
569       }
570 
571       if (estruturaFilha.getEstruturaEtts() != null && !estruturaFilha.getEstruturaEtts().isEmpty()) {
572 
573         retorno.addAll(getEstruturasFilhas(estruturaFilha));
574       }
575     }
576 
577     return retorno;
578   }
579 
580   /**
581    * Gera o arquivo de exportação para o monitoramento
582    * @param configuracao
583    * @param mesReferencia
584    * @return List de String[], onde: posicao 0 --> caminho do arquivo gravado no
585    *         servidor posicao 1 --> nome do arquivo gerado
586    * @throws ECARException
587    */
588   public List gerarArquivosExportacaoMonitoramentoPorReferenciaTxt(ConfiguracaoCfg configuracao, String mesReferencia, String niveisPlanejamento, String codTipoAcompanhamento, String semInformacaoNivelPlanejamento, String filtroSituacoes) throws ECARException {
589 
590     String linha = "";
591     int numeroListas = 0;
592     List retorno = new ArrayList();
593     List itensAcompanhamentos = new ArrayList();
594 
595     this.separadorCampos = configuracao.getSeparadorArqTXT();
596     this.separadorMultivalor = configuracao.getSeparadorCampoMultivalor();
597 
598     // configuração de upload
599     String caminho = configuracao.getRaizUpload() + configuracao.getUploadExportacaoDemandas();
600     // indica que o relatorio é do tipo monitoramento
601     String relatorioTipoMonitoramento = "S";
602 
603     int sequencialItensPai = 1;
604     int sequencialItemPaiAtual = 1;
605 
606     try {
607       List itensEstruturaIett = new ArrayList();
608       List itensPais = new ArrayList();
609       ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(request);
610       EstruturaDao estruturaDao = new EstruturaDao(request);
611       AcompReferenciaItemDao acompReferenciaItemDao = new AcompReferenciaItemDao(request);
612       AcompReferenciaDao acompReferenciaDao = new AcompReferenciaDao(request);
613       SisAtributoDao sisAtributoDao = new SisAtributoDao(request);
614       ItemEstruturaDao itemDao = new ItemEstruturaDao(request);
615       TipoFuncAcompDao tipoFuncAcompDao = new TipoFuncAcompDao(request);
616       UsuarioDao usuarioDao = new UsuarioDao(request);
617       OrgaoDao orgaoDao = new OrgaoDao(request);
618       CorDao corDao = new CorDao(request);
619       AbaDao abaDao = new AbaDao(request);
620       ConfiguracaoDao configuracaoDao = new ConfiguracaoDao(request);
621       TipoAcompanhamentoDao taDao = new TipoAcompanhamentoDao(request);
622       AcompReferenciaAref acompReferenciaAref = (AcompReferenciaAref) acompReferenciaDao.buscar(AcompReferenciaAref.class, Long.valueOf(mesReferencia));
623       String exigeLiberarAcompanhamento = acompReferenciaAref.getTipoAcompanhamentoTa().getIndLiberarAcompTa();
624 
625       SegurancaECAR seguranca = (SegurancaECAR) request.getSession().getAttribute("seguranca");
626       UsuarioUsu usuario = seguranca.getUsuario();
627 
628       String periodo = "1";
629 
630       OrgaoOrg orgaoResponsavel = new OrgaoOrg();
631 
632       if (mesReferencia != null && !"".equals(mesReferencia)) {
633         List listNiveis = new ArrayList();
634         String[] niveis = niveisPlanejamento.split(":");
635         for (int n = 0; n < niveis.length; n++) {
636           String codNivel = niveis[n];
637 
638           if (!"".equals(codNivel)) {
639             listNiveis.add(sisAtributoDao.buscar(SisAtributoSatb.class, Long.valueOf(codNivel)));
640           }
641         }
642 
643         StatusRelatorioSrl statusLiberado = (StatusRelatorioSrl) itemDao.buscar(StatusRelatorioSrl.class, Long.valueOf(AcompReferenciaItemDao.STATUS_LIBERADO));
644 
645         boolean primeiro = true;
646 
647         Long codArefReferencia = Long.valueOf(mesReferencia);
648         int qtdePeriodosAnteriores = Integer.valueOf(periodo).intValue();
649 
650         /* Busca coleção com períodos a serem considereados */
651         Collection periodosConsiderados = new ArrayList();
652 
653         if (codArefReferencia.intValue() > 0) {
654           periodosConsiderados = acompReferenciaDao.getPeriodosAnteriores(codArefReferencia, qtdePeriodosAnteriores, Long.valueOf(codTipoAcompanhamento));
655         }
656 
657         /* seta na sessão coleção de periodos, para ser utilizado no grafico */
658         Boolean isSemInformacaoNivelPlanejamento = new Boolean(false);
659         if ("S".equals(semInformacaoNivelPlanejamento)) {
660           isSemInformacaoNivelPlanejamento = new Boolean(true);
661         }
662         /*
663          * Recupera lista de itens para os periodos considerados por orgão
664          * responsavel
665          */
666 
667         Long situacao = null;
668         if (!"".equals(filtroSituacoes)) {
669           situacao = Long.valueOf(filtroSituacoes);
670         }
671 
672         // String indLiberado = "S";
673         // if("N".equals(exigeLiberarAcompanhamento)){
674         // indLiberado = "";
675         // }
676 
677         // Gerar também os ítens que não estão com o acompanhamento do item
678         // liberado
679         // Alteração solicitada por Ueda: Doc. de Re-Homologação de 01/10/2008
680         String indLiberado = "";
681 
682         Object itens[] = acompReferenciaItemDao.getItensAcompanhamentoInPeriodosByOrgaoResp(periodosConsiderados, listNiveis, orgaoResponsavel, usuario, seguranca.getGruposAcesso(), Long.valueOf(codTipoAcompanhamento), null, isSemInformacaoNivelPlanejamento, situacao, indLiberado);
683 
684         itensAcompanhamentos = new ArrayList((Collection) itens[0]);
685 
686       }
687 
688       // separar por item de estrutura
689       List itensEstruturaIettSeparadasPorEstrutura = separaPorEstrutura(itensAcompanhamentos);
690       int sequencialEstrutura = 1;
691 
692       if (itensEstruturaIettSeparadasPorEstrutura != null) {
693 
694         for (int i = 0; i < itensEstruturaIettSeparadasPorEstrutura.size(); i++) {
695 
696           int sequencialItens = 1;
697           sequencialItensPai = 1;
698 
699           List itensEstruturaIettPorNivel = (List) itensEstruturaIettSeparadasPorEstrutura.get(i);
700 
701           ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) itensEstruturaIettPorNivel.get(0);
702 
703           String caminhoCompleto = "";
704           // Cria o nome do arquivo -> <ID Sequencial>_<Nome da Estrutura
705           // Pai>_<Nome da Estrutura Utilizada>.txt
706           String nomeArquivo = String.valueOf(sequencialEstrutura);
707           if (itemEstrutura != null && itemEstrutura.getEstruturaEtt() != null) {
708             EstruturaEtt estruturaCorrente = itemEstrutura.getEstruturaEtt();
709             if (estruturaCorrente.getEstruturaEtt() != null) {
710               if (!estruturaCorrente.getEstruturaEtt().getNomeEtt().equals(""))
711                 nomeArquivo += "_" + estruturaCorrente.getEstruturaEtt().getNomeEtt();
712               else
713                 nomeArquivo += "_" + estruturaCorrente.getEstruturaEtt().getLabelEtt();
714             }
715             if (!estruturaCorrente.getNomeEtt().equals(""))
716               nomeArquivo += "_" + estruturaCorrente.getNomeEtt();
717             else
718               nomeArquivo += "_" + estruturaCorrente.getLabelEtt();
719           }
720 
721           nomeArquivo += ".txt";
722 
723           nomeArquivo = nomeArquivo.replaceAll("/", "-");
724 
725           sequencialEstrutura++;
726 
727           caminhoCompleto = caminho + "/" + nomeArquivo;
728 
729           String[] caminhoArquivo = { caminhoCompleto, nomeArquivo };
730           retorno.add(caminhoArquivo);
731 
732           File diretorio = new File(caminho);
733 
734           if (!diretorio.isDirectory())
735             diretorio.mkdirs();
736 
737           FileOutputStream arquivo = new FileOutputStream(caminhoCompleto);
738 
739           // Monta o cabeçalho
740           if (itemEstrutura != null) {
741             // monta o cabeçalho com nomes e os pareceres
742             linha += montaCabecalhoMonitoramento(itemEstrutura, acompReferenciaAref, configuracao);
743 
744             // monta o cabeçalho com os dados gerais
745             List<ObjetoEstrutura> atributosOrdenados = estruturaDao.getAtributosEstruturaDadosGerais(itemEstrutura.getEstruturaEtt());
746             Iterator atributosOrdenadosIt = atributosOrdenados.iterator();
747 
748             linha += montaLinhaCabecalhoEstrutura(atributosOrdenadosIt, itemEstrutura.getEstruturaEtt(), relatorioTipoMonitoramento);
749           }
750 
751           ItemEstruturaIett itemEstruturaPaiCorrente = null;
752 
753           for (int j = 0; j < itensEstruturaIettPorNivel.size(); j++) {
754             itemEstrutura = (ItemEstruturaIett) itensEstruturaIettPorNivel.get(j);
755 
756             // Consulta o itemEstrutura pois quando vai pegar a coleção de
757             // atributos livres dá erro de hibernate (lazy)
758             itemEstrutura = (ItemEstruturaIett) itemEstruturaDao.buscar(ItemEstruturaIett.class, itemEstrutura.getCodIett());
759             EstruturaEtt estruturaCorrente = null;
760 
761             if (itemEstrutura != null)
762               estruturaCorrente = itemEstrutura.getEstruturaEtt();
763 
764             // Se for o primeiro item o item pai passa a ser o pai desse item
765             if (itemEstruturaPaiCorrente == null && itemEstrutura.getItemEstruturaIett() != null) {
766               sequencialItemPaiAtual = verificaSequencialPai(itemEstrutura, itensPais);
767               itemEstruturaPaiCorrente = itemEstrutura.getItemEstruturaIett();
768             }
769 
770             // Se o próximo item tiver um item pai diferente do anterior, o
771             // sequencial de itens pais é
772             // incrementado e um novo item pai corrente é atribuido
773             if (itemEstruturaPaiCorrente != null && !itemEstruturaPaiCorrente.equals(itemEstrutura.getItemEstruturaIett())) {
774               sequencialItemPaiAtual = verificaSequencialPai(itemEstrutura, itensPais);
775               itemEstruturaPaiCorrente = itemEstrutura.getItemEstruturaIett();
776             }
777 
778             int[] pai = { itemEstrutura.getCodIett().intValue(), sequencialItensPai };
779             itensPais.add(pai);
780             sequencialItensPai++;
781 
782             List<ObjetoEstrutura> atributosOrdenados = estruturaDao.getAtributosEstruturaDadosGerais(estruturaCorrente);
783 
784             if (atributosOrdenados != null) {
785 
786               Iterator<ObjetoEstrutura> atributosOrdenadosIt = atributosOrdenados.iterator();
787 
788               // monta a linha com os sequenciais e pareceres
789               linha += montaLinhaMonitoramento(itemEstrutura, acompReferenciaAref, sequencialItemPaiAtual, sequencialItens, configuracao);
790               // monta a linha com os dados básicos
791               linha += montaLinhaItemEstruturaComCamposOrdenados(atributosOrdenadosIt, itemEstrutura, sequencialItemPaiAtual, sequencialItens, relatorioTipoMonitoramento, configuracao, acompReferenciaAref);
792 
793               sequencialItens++;
794 
795             }
796 
797           }
798 
799           // escreve linha no arquivo .txt
800           linha = Util.normalizaCaracterMarcador(linha);
801           arquivo.write(linha.getBytes());
802           arquivo.flush();
803           linha = "";
804         }
805       }
806 
807     } catch (Exception e) {
808       Logger logger = Logger.getLogger(this.getClass());
809       logger.error(e);
810     }
811 
812     return retorno;
813 
814   }
815 
816   /**
817    * Método que monta a linha com o cabeçalho para a criação do txt para a parte
818    * de monitoramento. A linha deve seguir o padrão:
819    * <campo1>[separador]<campo2>[separador]<campo3>...[quebra de linha]
820    * @param itemEstruturaIett
821    * @param acompReferenciaAref
822    * @param configuracao
823    * @return linha
824    */
825   private String montaCabecalhoMonitoramento(ItemEstruturaIett itemEstruturaIett, AcompReferenciaAref acompReferenciaAref, ConfiguracaoCfg configuracao) throws ECARException {
826     String linhaRetorno = "";
827 
828     try {
829 
830       if (itemEstruturaIett != null && acompReferenciaAref != null) {
831 
832         // Campo: Tipo Acompanhamento
833         if (acompReferenciaAref.getTipoAcompanhamentoTa() != null) {
834           linhaRetorno += acompReferenciaAref.getTipoAcompanhamentoTa().getDescricaoTa().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
835           linhaRetorno += this.separadorCampos;
836         }
837 
838         // Campo:Mes de Referencia
839         if (acompReferenciaAref.getTipoAcompanhamentoTa() != null) {
840           linhaRetorno += acompReferenciaAref.getNomeAref().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
841           linhaRetorno += this.separadorCampos;
842         }
843 
844       }
845 
846       // Campo: Nome da Estrutura Pai (quando o ítem não for do primeiro nível)
847       if (itemEstruturaIett.getEstruturaEtt().getEstruturaEtt() != null) {
848         linhaRetorno += "ID_" + itemEstruturaIett.getEstruturaEtt().getEstruturaEtt().getNomeEtt().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
849         linhaRetorno += this.separadorCampos;
850       }
851       else {
852         // se nao tiver pai deixa em branco ( no caso do primeiro nivel)
853         linhaRetorno += this.separadorCampos;
854       }
855 
856       // Campo: Nome da Estrutura Atual
857       if (itemEstruturaIett.getEstruturaEtt() != null) {
858         linhaRetorno += "ID_" + itemEstruturaIett.getEstruturaEtt().getNomeEtt().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
859         linhaRetorno += this.separadorCampos;
860       }
861 
862       // Campo:Nome do Item
863       linhaRetorno += "Nome do Item";
864       linhaRetorno += this.separadorCampos;
865 
866       // Mostrar todas as funções de acompanhamento da estrutura
867       EstruturaEtt estrutura = itemEstruturaIett.getEstruturaEtt();
868       Set funcoesAcompanhamento = estrutura.getEstrutTpFuncAcmpEtttfas();
869 
870       if (funcoesAcompanhamento != null) {
871         Iterator itTpFunAnt = funcoesAcompanhamento.iterator();
872         while (itTpFunAnt.hasNext()) {
873           EstrutTpFuncAcmpEtttfa estruturaTpFuncaoAnt = (EstrutTpFuncAcmpEtttfa) itTpFunAnt.next();
874 
875           // Campo: Função de Acompanhamento
876           linhaRetorno += "Função de Acompanhamento";
877           linhaRetorno += this.separadorCampos;
878 
879           // Campo: Label da Situação em Configuração Geral
880           linhaRetorno += configuracao.getLabelSituacaoParecer().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
881           linhaRetorno += this.separadorCampos;
882 
883           // Campo: Label da Cor em Configuração Geral
884           linhaRetorno += configuracao.getLabelCorParecer().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
885           linhaRetorno += this.separadorCampos;
886 
887           // Campo: Label da posição em função de acompanhamento
888           if (estruturaTpFuncaoAnt.getTipoFuncAcompTpfa() != null)
889             linhaRetorno += estruturaTpFuncaoAnt.getTipoFuncAcompTpfa().getLabelPosicaoTpfa().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
890           linhaRetorno += this.separadorCampos;
891 
892           // Campo: Observação
893           String ocultarObservacoesParecer = configuracao.getIndOcultarObservacoesParecer();
894           if (ocultarObservacoesParecer == null || ocultarObservacoesParecer.equals("N")) {
895             linhaRetorno += "Observação";
896             linhaRetorno += this.separadorCampos;
897           }
898 
899         }
900 
901       }
902 
903     } catch (Exception e) {
904       Logger logger = Logger.getLogger(this.getClass());
905       logger.error(e);
906     }
907 
908     return linhaRetorno;
909   }
910 
911   /**
912    * Método que monta a linha para cada item de estrutura. A linha deve seguir o
913    * padrão: <campo1>[separador]<campo2>[separador]<campo3>...[quebra de linha]
914    * @param itemEstruturaIett
915    * @param acompReferenciaAref
916    * @param sequencialItensPai
917    * @param sequencialItens
918    * @return linha
919    */
920   private String montaLinhaMonitoramento(ItemEstruturaIett itemEstruturaIett, AcompReferenciaAref acompReferenciaAref, int sequencialItensPai, int sequencialItens, ConfiguracaoCfg configuracao) throws ECARException {
921 
922     String linhaRetorno = "";
923     AcompReferenciaDao acompReferenciaDao = new AcompReferenciaDao(request);
924     AcompReferenciaItemDao acompReferenciaItemDao = new AcompReferenciaItemDao(request);
925     AcompReferenciaItemDao ariDao = new AcompReferenciaItemDao(request);
926     CorDao corDao = new CorDao(request);
927     TipoFuncAcompDao tipoFuncAcompDao = new TipoFuncAcompDao(request);
928     ItemEstruturaDao itemDao = new ItemEstruturaDao(request);
929 
930     String flag = "";
931 
932     try {
933 
934       // Campo: Tipo Acompanhamento - Na linha vai pular esse campo
935       if (acompReferenciaAref.getTipoAcompanhamentoTa() != null) {
936         linhaRetorno += "";
937         linhaRetorno += this.separadorCampos;
938       }
939 
940       // Campo:Mes de Referencia - Na linha vai pular esse campo
941       if (acompReferenciaAref.getTipoAcompanhamentoTa() != null) {
942         linhaRetorno += "";
943         linhaRetorno += this.separadorCampos;
944       }
945 
946       // Campo: Nome do Pai - Na linha vai ser o sequencial referenciado
947       if (itemEstruturaIett.getItemEstruturaIett() != null)
948         linhaRetorno += sequencialItensPai;
949       linhaRetorno += this.separadorCampos;
950 
951       // Campo: Nome da Estrutura Atual - Na linha vai ser o sequencial
952       linhaRetorno += sequencialItens;
953       linhaRetorno += this.separadorCampos;
954 
955       // Campo: Nome do Item - Na linha -> Label
956       linhaRetorno += itemEstruturaIett.getNomeIett().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
957       linhaRetorno += this.separadorCampos;
958 
959       Collection periodosConsiderados = new ArrayList();// varre todas as
960                                                         // estruturas do nível
961                                                         // corrente e gera uma
962                                                         // lista com as
963                                                         // estruturas filhas
964                                                         // também
965       periodosConsiderados.add(acompReferenciaAref);
966       List tpfaOrdenadosPorEstrutura = tipoFuncAcompDao.getFuncaoAcompOrderByEstruturas();
967       String exigeLiberarAcompanhamento = acompReferenciaAref.getTipoAcompanhamentoTa().getIndLiberarAcompTa();
968       String ocultarObservacoesParecer = configuracao.getIndOcultarObservacoesParecer();
969       StatusRelatorioSrl statusLiberado = (StatusRelatorioSrl) itemDao.buscar(StatusRelatorioSrl.class, Long.valueOf(AcompReferenciaItemDao.STATUS_LIBERADO));
970       SegurancaECAR seguranca = (SegurancaECAR) request.getSession().getAttribute("seguranca");
971 
972       Iterator itPeriodos = periodosConsiderados.iterator();
973       Map map = acompReferenciaItemDao.criarMapPeriodoAri(periodosConsiderados, itemEstruturaIett);
974 
975       List listaPareceres = new ArrayList();
976 
977       while (itPeriodos.hasNext()) {
978         AcompReferenciaAref acompReferencia = (AcompReferenciaAref) itPeriodos.next();
979         AcompReferenciaItemAri ari = (AcompReferenciaItemAri) map.get(acompReferencia);
980 
981         if (!map.isEmpty()) {
982 
983           // if("N".equals(exigeLiberarAcompanhamento) ||
984           // ari.getStatusRelatorioSrl().equals(statusLiberado)){
985           List relatorios = acompReferenciaItemDao.getAcompRelatorioArelOrderByFuncaoAcomp(ari, tpfaOrdenadosPorEstrutura);
986           Iterator itRelatorios = relatorios.iterator();
987 
988           ValidaPermissao validaPermissao = new ValidaPermissao();
989           List listaPermissaoTpfa = validaPermissao.permissaoVisualizarPareceres(acompReferenciaAref.getTipoAcompanhamentoTa(), seguranca.getGruposAcesso());
990 
991           while (itRelatorios.hasNext()) {
992 
993             AcompRelatorioArel relatorio = (AcompRelatorioArel) itRelatorios.next();
994             if (listaPermissaoTpfa.contains(relatorio.getTipoFuncAcompTpfa())) {
995 
996               listaPareceres.add(relatorio);
997             }
998           }
999 
1000           // } else if("N".equals(exigeLiberarAcompanhamento) ||
1001           // (ari.getAcompRelatorioArels() != null &&
1002           // ari.getAcompRelatorioArels().size() > 0)) {
1003 
1004           // Campo: Nome do Item - Na linha -> Label
1005           // linhaRetorno += "N/L";
1006           // linhaRetorno += this.separadorCampos;
1007 
1008           // Campo Função de Acompanhamento - Na linha -> Label da função de
1009           // acompanhamento
1010           // linhaRetorno += "N/L";
1011           // linhaRetorno += this.separadorCampos;
1012           //						
1013           //						
1014           // //Campo Situção - Na linha -> Atrasado
1015           // linhaRetorno += "N/L";
1016           // linhaRetorno += this.separadorCampos;
1017           //						
1018           // //Campo Cor- Linha -> vermelho
1019           // linhaRetorno += "N/L";
1020           // linhaRetorno += this.separadorCampos;
1021           //						
1022           // //Campo Label da posição em função de acompanhamento - Linha:
1023           // Repete o mesmo do cabeçalho
1024           // linhaRetorno += "N/L";
1025           // linhaRetorno += this.separadorCampos;
1026           //						
1027           // //Campo: Observação
1028           // if (ocultarObservacoesParecer == null ||
1029           // ocultarObservacoesParecer.equals("N")) {
1030           // linhaRetorno += "N/L";
1031           // linhaRetorno += this.separadorCampos;
1032           // }
1033           // }
1034         }
1035       }
1036 
1037       StatusRelatorioSrl statusAri = null;
1038       if (listaPareceres != null) {
1039 
1040         EstruturaEtt estrutura = itemEstruturaIett.getEstruturaEtt();
1041         Set funcoesAcompanhamento = estrutura.getEstrutTpFuncAcmpEtttfas();
1042 
1043         if (funcoesAcompanhamento != null) {
1044           Iterator itTpFunAnt = funcoesAcompanhamento.iterator();
1045           while (itTpFunAnt.hasNext()) {
1046             EstrutTpFuncAcmpEtttfa estruturaTpFuncaoAnt = (EstrutTpFuncAcmpEtttfa) itTpFunAnt.next();
1047             boolean achou = false;
1048             for (int i = 0; i < listaPareceres.size(); i++) {
1049               AcompRelatorioArel relatorio = (AcompRelatorioArel) listaPareceres.get(i);
1050 
1051               statusAri = relatorio.getAcompReferenciaItemAri().getStatusRelatorioSrl();
1052 
1053               if (relatorio.getTipoFuncAcompTpfa().getCodTpfa().equals(estruturaTpFuncaoAnt.getTipoFuncAcompTpfa().getCodTpfa())) {
1054 
1055                 if ("S".equals(exigeLiberarAcompanhamento) && !relatorio.getAcompReferenciaItemAri().getStatusRelatorioSrl().equals(statusLiberado)) {
1056                   // Campo Função de Acompanhamento - Na linha -> Label da
1057                   // função de acompanhamento
1058                   linhaRetorno += estruturaTpFuncaoAnt.getTipoFuncAcompTpfa().getLabelTpfa().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
1059                   linhaRetorno += this.separadorCampos;
1060                   // Campo Situção - Na linha -> Atrasado
1061                   linhaRetorno += "N/L";
1062                   linhaRetorno += this.separadorCampos;
1063                   // Campo Cor- Linha -> vermelho
1064                   linhaRetorno += "N/L";
1065                   linhaRetorno += this.separadorCampos;
1066                   // Campo Label da posição em função de acompanhamento - Linha:
1067                   // Repete o mesmo do cabeçalho
1068                   linhaRetorno += "N/L";
1069                   linhaRetorno += this.separadorCampos;
1070                   // Campo: Observação // Pode estar configurado para ser
1071                   // ocultado
1072                   if (ocultarObservacoesParecer == null || ocultarObservacoesParecer.equals("N")) {
1073                     linhaRetorno += "N/L";
1074                     linhaRetorno += this.separadorCampos;
1075                   }
1076                   achou = true;
1077                   break;
1078                 }
1079                 else {
1080                   // Campo Função de Acompanhamento - Na linha -> Label da
1081                   // função de acompanhamento
1082                   linhaRetorno += relatorio.getTipoFuncAcompTpfa().getLabelTpfa().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
1083                   linhaRetorno += this.separadorCampos;
1084 
1085                   // Campo Situção - Na linha -> Atrasado
1086                   if (relatorio.getSituacaoSit() != null)
1087                     linhaRetorno += relatorio.getSituacaoSit().getDescricaoSit().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
1088                   else
1089                     linhaRetorno += "N/I";
1090 
1091                   linhaRetorno += this.separadorCampos;
1092 
1093                   // Campo Cor- Linha -> vermelho
1094                   if (relatorio.getCor() != null)
1095                     linhaRetorno += relatorio.getCor().getSignificadoCor().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
1096                   else
1097                     linhaRetorno += "N/I";
1098 
1099                   linhaRetorno += this.separadorCampos;
1100 
1101                   // Campo Label da posição em função de acompanhamento - Linha:
1102                   // Repete o mesmo do cabeçalho
1103                   if (relatorio.getDescricaoArel() != null)
1104                     linhaRetorno += relatorio.getDescricaoArel().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
1105                   linhaRetorno += this.separadorCampos;
1106 
1107                   // Campo: Observação // Pode estar configurado para ser
1108                   // ocultado
1109                   if (ocultarObservacoesParecer == null || ocultarObservacoesParecer.equals("N")) {
1110                     if (relatorio.getComplementoArel() != null && !"".equals(relatorio.getComplementoArel().trim()))
1111                       linhaRetorno += relatorio.getComplementoArel().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
1112                     else
1113                       linhaRetorno += "N/I";
1114 
1115                     linhaRetorno += this.separadorCampos;
1116                   }
1117 
1118                   achou = true;
1119                   break;
1120 
1121                 }
1122 
1123               }
1124 
1125             }
1126 
1127             if (achou == false) {
1128               if ("S".equals(exigeLiberarAcompanhamento) && statusAri != null && !statusAri.equals(statusLiberado)) {
1129                 // Campo Função de Acompanhamento - Na linha -> Label da função
1130                 // de acompanhamento
1131                 linhaRetorno += estruturaTpFuncaoAnt.getTipoFuncAcompTpfa().getLabelTpfa().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
1132                 linhaRetorno += this.separadorCampos;
1133                 // Campo Situção - Na linha -> Atrasado
1134                 linhaRetorno += "N/L";
1135                 linhaRetorno += this.separadorCampos;
1136                 // Campo Cor- Linha -> vermelho
1137                 linhaRetorno += "N/L";
1138                 linhaRetorno += this.separadorCampos;
1139                 // Campo Label da posição em função de acompanhamento - Linha:
1140                 // Repete o mesmo do cabeçalho
1141                 linhaRetorno += "N/L";
1142                 linhaRetorno += this.separadorCampos;
1143                 // Campo: Observação // Pode estar configurado para ser ocultado
1144                 if (ocultarObservacoesParecer == null || ocultarObservacoesParecer.equals("N")) {
1145                   linhaRetorno += "N/L";
1146                   linhaRetorno += this.separadorCampos;
1147                 }
1148               }
1149               else {
1150                 // Campo Função de Acompanhamento - Na linha -> Label da função
1151                 // de acompanhamento
1152                 linhaRetorno += estruturaTpFuncaoAnt.getTipoFuncAcompTpfa().getLabelTpfa().replaceAll("\n", " ").replaceAll("\r", " ").replaceAll("\t", " ");
1153                 linhaRetorno += this.separadorCampos;
1154                 // Campo Situção - Na linha -> Atrasado
1155                 linhaRetorno += this.separadorCampos;
1156                 // Campo Cor- Linha -> vermelho
1157                 linhaRetorno += this.separadorCampos;
1158                 // Campo Label da posição em função de acompanhamento - Linha:
1159                 // Repete o mesmo do cabeçalho
1160                 linhaRetorno += this.separadorCampos;
1161                 // Campo: Observação // Pode estar configurado para ser ocultado
1162                 if (ocultarObservacoesParecer == null || ocultarObservacoesParecer.equals("N")) {
1163                   linhaRetorno += this.separadorCampos;
1164 
1165                 }
1166               }
1167             }
1168           }
1169         }
1170       }
1171 
1172     } catch (Exception e) {
1173       Logger logger = Logger.getLogger(this.getClass());
1174       logger.error(e);
1175     }
1176 
1177     return Util.stripHTML(Util.normalizaCaracterMarcador(linhaRetorno));
1178 
1179   }
1180 
1181   /**
1182    * Método que separa os itens por estruturas
1183    * @param itensEstruturaIett
1184    * @return itensSeparadosPorNiveis
1185    */
1186   public List separaPorEstrutura(List itensEstruturaIett) {
1187 
1188     List niveis = new ArrayList();
1189 
1190     // verifica quais os niveis presentes
1191     // AtributoEstruturaListagemItens aeIett = (AtributoEstruturaListagemItens)
1192     // itItens.next();
1193 
1194     Iterator itItensEstruturaIett = itensEstruturaIett.iterator();
1195 
1196     while (itItensEstruturaIett.hasNext()) {
1197       AtributoEstruturaListagemItens aeIett = (AtributoEstruturaListagemItens) itItensEstruturaIett.next();
1198       ItemEstruturaIett itemEstruturaIett = aeIett.getItem();
1199       // ItemEstruturaIett itemEstruturaIett = (ItemEstruturaIett)
1200       // itItensEstruturaIett.next();
1201       if (!niveis.contains(itemEstruturaIett.getNivelIett()))
1202         niveis.add(itemEstruturaIett.getNivelIett());
1203     }
1204 
1205     // separa por niveis
1206     List itensSeparadosPorNiveis = new ArrayList();
1207     Iterator itNiveis = niveis.iterator();
1208     while (itNiveis.hasNext()) {
1209       Integer nivel = (Integer) itNiveis.next();
1210       itensSeparadosPorNiveis.add(separaPorNivel(itensEstruturaIett, nivel));
1211     }
1212 
1213     return (itensSeparadosPorNiveis);
1214   }
1215 
1216   /**
1217    * Método que separa os itens de acordo com o nivel passado como parametro
1218    * @param itensEstruturaIett
1219    * @param nivel
1220    * @return itensSeparadosPorNivel
1221    */
1222   public List separaPorNivel(List itensEstruturaIett, Integer nivel) {
1223 
1224     List itensSeparadosPorNivel = new ArrayList();
1225     Iterator itItensEstruturaIett = itensEstruturaIett.iterator();
1226     while (itItensEstruturaIett.hasNext()) {
1227       AtributoEstruturaListagemItens aeIett = (AtributoEstruturaListagemItens) itItensEstruturaIett.next();
1228       ItemEstruturaIett itemEstruturaIett = aeIett.getItem();
1229       // ItemEstruturaIett itemEstruturaIett = (ItemEstruturaIett)
1230       // itItensEstruturaIett.next();
1231       if (itemEstruturaIett.getNivelIett().equals(nivel)) {
1232         itensSeparadosPorNivel.add(itemEstruturaIett);
1233       }
1234 
1235     }
1236 
1237     return itensSeparadosPorNivel;
1238 
1239   }
1240 
1241   /**
1242    * Método que verifica se o item passado por parâmetro pertence ao Aref
1243    * @param itensEstruturaIett
1244    * @param acompReferenciaAref
1245    * @return itemPertenceAref
1246    */
1247   private boolean verificarItemPertenceAref(ItemEstruturaIett itemEstruturaIett, AcompReferenciaAref acompReferenciaAref) {
1248     boolean itemPertenceAref = false;
1249 
1250     if (acompReferenciaAref != null && itemEstruturaIett != null) {
1251       if (acompReferenciaAref.getAcompReferenciaItemAris() != null) {
1252         Iterator itAris = acompReferenciaAref.getAcompReferenciaItemAris().iterator();
1253         while (itAris.hasNext()) {
1254           AcompReferenciaItemAri acompReferenciaItemAri = (AcompReferenciaItemAri) itAris.next();
1255           if (acompReferenciaItemAri.getItemEstruturaIett().equals(itemEstruturaIett)) {
1256             itemPertenceAref = true;
1257             break;
1258           }
1259         }
1260       }
1261     }
1262 
1263     return itemPertenceAref;
1264   }
1265 
1266 }