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.Iterator;
7   import java.util.List;
8   
9   import javax.servlet.http.HttpServletRequest;
10  
11  import org.apache.log4j.Logger;
12  
13  import comum.database.Dao;
14  import comum.util.Util;
15  
16  import ecar.exception.ECARException;
17  import ecar.pojo.ApontamentoAnexo;
18  import ecar.pojo.ConfiguracaoCfg;
19  import ecar.pojo.DemAtributoDema;
20  import ecar.pojo.ObjetoDemanda;
21  import ecar.pojo.RegApontamentoRegda;
22  import ecar.pojo.RegDemandaRegd;
23  import ecar.pojo.SisAtributoSatb;
24  
25  public class ExportacaoRelatorioDemandasDao extends Dao {
26  
27    private String separadorCampos;
28    private String separadorMultivalor;
29  
30    /**
31     * Construtor. Chama o Session factory do Hibernate
32     */
33    public ExportacaoRelatorioDemandasDao(HttpServletRequest request) {
34      super();
35      this.request = request;
36    }
37  
38    /**
39     * Gera o arquivo de exportação
40     * @param nomeArquivo
41     * @param configuracao
42     * @return String[]: posicao 0 --> caminho do arquivo gravado no servidor
43     *         posicao 1 --> nome do arquivo gerado
44     * @throws ECARException
45     */
46    public String[] gerarArquivoExportacaoTxt(String nomeArquivo, List<RegDemandaRegd> listaDemandas, ConfiguracaoCfg configuracao) throws ECARException {
47  
48      this.separadorCampos = configuracao.getSeparadorArqTXT();
49      this.separadorMultivalor = configuracao.getSeparadorCampoMultivalor();
50  
51      RegDemandaDao regDemandaDao = new RegDemandaDao(null);
52  
53      // configuração de upload
54      String caminho = configuracao.getRaizUpload() + configuracao.getUploadExportacaoDemandas();
55      // String caminho = "/home/03909001416" +
56      // configuracao.getUploadExportacaoDemandas();
57  
58      if (!caminho.endsWith("/"))
59        caminho = caminho + "/";
60  
61      String caminhoCompleto = "";
62  
63      try {
64  
65        nomeArquivo += "_export.txt";
66        caminhoCompleto = caminho + nomeArquivo;
67  
68        File diretorio = new File(caminho);
69  
70        if (!diretorio.isDirectory())
71          diretorio.mkdirs();
72  
73        FileOutputStream arquivo = new FileOutputStream(caminhoCompleto);
74  
75        String linha = "";
76  
77        // Consulta qual a sequência dos atributos da demanda
78        AtributoDemandaDao atributoDemandaDao = new AtributoDemandaDao(null);
79        List<ObjetoDemanda> atributosOrdenados = atributoDemandaDao.getAtributosDemandaAtivosOrdenadosPorSequenciaTelaCampo();
80        Iterator<ObjetoDemanda> atributosOrdenadosIt = null;
81  
82        if (listaDemandas != null && !listaDemandas.isEmpty() && atributosOrdenados != null && !atributosOrdenados.isEmpty()) {
83  
84          // Para cada demanda criar a linhas da demanda e dos apontamentos
85          Iterator<RegDemandaRegd> listaDemandasIt = listaDemandas.iterator();
86          while (listaDemandasIt.hasNext()) {
87  
88            // Demanda
89            RegDemandaRegd regDemanda = (RegDemandaRegd) listaDemandasIt.next();
90            // Consulta a regDemanda pois quando vai pegar a coleção de
91            // apontamentos e
92            // de atributos livres dá erro de hibernate (lazy)
93            regDemanda = (RegDemandaRegd) regDemandaDao.buscar(RegDemandaRegd.class, regDemanda.getCodRegd());
94  
95            atributosOrdenadosIt = atributosOrdenados.iterator();
96            int numeroCamposApontamento = 4;// Em apontamentos só tem campos fixos
97  
98            /*
99             * Para cada demanda escreve uma linha:
100            * <campo1>[separador]<campo2>[separador
101            * ]<campo3>...[separador][separador][separador][quebra de linha]
102            * Campo deve estar na mesma ordem que está sendo exibida na tela de
103            * cadastro --> atributosOrdenados
104            */
105           linha = montaLinhaDemandaComCamposOrdenados(atributosOrdenadosIt, regDemanda, numeroCamposApontamento);
106           // escreve linha no arquivo .txt
107           linha = Util.normalizaCaracterMarcador(linha);
108           arquivo.write(linha.getBytes());
109           arquivo.flush();
110 
111           // Para cada demanda, verifica sem tem apontamentos,
112           // e escreve as linhas com os campos dos apontamentos
113           if (regDemanda.getRegApontamentoRegdas() != null && regDemanda.getRegApontamentoRegdas().size() > 0) {
114 
115             /*
116              * Para cada demanda, consulta os apontamentos e para cada
117              * apontamento escreve uma linha:
118              * [separador][separador][separador]<campo1
119              * >[separador]<campo2>...[quebra de linha] Obs.: O início da linha
120              * de cada apontamento inicia com 'n' separadores, sendo 'n' o
121              * número de campos que uma demanda tem.
122              */
123             // Pega os Apontamentos da Demanda
124             List listaApontamentos = new ArrayList();
125             listaApontamentos.addAll(regDemanda.getRegApontamentoRegdas());
126 
127             // Se existir apontamentos na Demanda
128             if (listaApontamentos != null && listaApontamentos.size() > 0) {
129 
130               Iterator listaApontamentosIt = listaApontamentos.iterator();
131 
132               // Para cada apontamento criar a linha
133               while (listaApontamentosIt.hasNext()) {
134                 RegApontamentoRegda regApontamento = (RegApontamentoRegda) listaApontamentosIt.next();
135                 linha = montaLinhasApontamentosComCamposOrdenados(regDemanda, regApontamento, atributosOrdenados.size());
136                 // escreve linha no arquivo .txt
137                 linha = Util.normalizaCaracterMarcador(linha);
138                 arquivo.write(linha.getBytes());
139                 arquivo.flush();
140               }
141             }
142           }
143 
144         }
145       }
146 
147       // Fecha arquivo
148       arquivo.close();
149 
150     } catch (Exception e) {
151       Logger logger = Logger.getLogger(this.getClass());
152       logger.error(e);
153     }
154 
155     String[] retorno = { caminhoCompleto, nomeArquivo };
156 
157     return retorno;
158   }
159 
160   /**
161    * Método que monta a linha com os campos de demanda ordenados. A linha deve
162    * seguir o padrão:
163    * <campo1>[separador]<campo2>[separador]<campo3>...[separador
164    * ][separador][separador][quebra de linha] Ao final da linha deve haver
165    * tantos separadores quanto for o número de campos no cadastro de
166    * apontamento.
167    * @param pAtributosOrdenadosIt
168    * @param pRegDemanda
169    * @return linha
170    */
171   private String montaLinhaDemandaComCamposOrdenados(Iterator<ObjetoDemanda> pAtributosOrdenadosIt, RegDemandaRegd pRegDemanda, int pNumeroCamposDemanda) {
172 
173     String linhaRetorno = "";
174 
175     if (pAtributosOrdenadosIt != null) {
176       while (pAtributosOrdenadosIt.hasNext()) {
177         ObjetoDemanda atributo = (ObjetoDemanda) pAtributosOrdenadosIt.next();
178 
179         try {
180           // Se for atributo livre pega valor pelo DemAtributoDemas
181           if (atributo.iGetGrupoAtributosLivres() != null && (atributo.iGetGrupoAtributosLivres().getIndAtivoSga() != null && atributo.iGetGrupoAtributosLivres().getIndAtivoSga().equals("S"))) {
182 
183             if (pRegDemanda.getDemAtributoDemas() != null) {
184               String separadorParaCamposMulti = "";
185               String separadorParaCamposCheck = "";
186               // Iterador com os atributos livres da demanda em questao
187               Iterator<DemAtributoDema> itAtribLivres = pRegDemanda.getDemAtributoDemas().iterator();
188 
189               // Para cada atributo livre da demanda, verifica-se se este
190               // corresponde
191               // ao atributo que esta sendo tratado
192               while (itAtribLivres.hasNext()) {
193                 DemAtributoDema atributoDema = (DemAtributoDema) itAtribLivres.next();
194                 // Iterador com os atributos livres associados ao atributo em
195                 // questão
196                 Iterator<SisAtributoSatb> sisAtributosSatbIt = atributo.iGetGrupoAtributosLivres().getSisAtributoSatbs().iterator();
197 
198                 while (sisAtributosSatbIt.hasNext()) {
199                   SisAtributoSatb sisAtributo = (SisAtributoSatb) sisAtributosSatbIt.next();
200                   if ((sisAtributo).equals(atributoDema.getSisAtributoSatb())) {
201                     // Caso seja um atributo tipo texto
202                     if (atributoDema.getInformacao() != null) {
203                       linhaRetorno += separadorParaCamposMulti + atributoDema.getInformacao().replaceAll("\n", " ").replaceAll("\r", " ");
204                       separadorParaCamposMulti = this.separadorMultivalor;
205                       // Caso seja atributo tipo check, radio ou select
206                     }
207                     else if (atributoDema.getSisAtributoSatb().getDescricaoSatb() != null) {
208                       linhaRetorno += separadorParaCamposCheck + (atributoDema.getSisAtributoSatb().getDescricaoSatb()).replaceAll("\n", " ").replaceAll("\r", " ");
209                       separadorParaCamposCheck = this.separadorMultivalor;
210                       // Caso não tenha valor associado ao atributo
211                     }
212                     else {
213                       linhaRetorno += "";
214                     }
215                   }
216                 }
217               }
218               separadorParaCamposMulti = "";
219               separadorParaCamposCheck = "";
220             }
221           }
222           else {
223             // Se for campo fixo pega valor direto do atributo
224             linhaRetorno += atributo.iGetValor(pRegDemanda).replaceAll("\n", " ").replaceAll("\r", " ");
225           }
226           // escreve o separador entre cada campo
227           linhaRetorno += this.separadorCampos;
228         } catch (ECARException e) {
229         }
230       }
231 
232       // escreve o fim da linha com separadores e quebra de linha
233       if (!linhaRetorno.equals("")) {
234         // Numero de separadores é dado pelo numero de campos que existe no
235         // cadastro de apontamento
236         for (int i = 1; i <= pNumeroCamposDemanda - 1; i++)
237           linhaRetorno += this.separadorCampos;
238 
239         linhaRetorno = linhaRetorno.replaceAll("\n", " ").replaceAll("\r", " ");
240 
241         // Quebra de Linha
242         linhaRetorno += "\n";
243       }
244     }
245 
246     return linhaRetorno;
247   }
248 
249   /**
250    * Método que monta as linhas com os apontamentos. Cada linha contem os campos
251    * do apontamento ordenados. A linha deve seguir o padrão:
252    * [separador][separador
253    * ][separador]<campo1>[separador]<campo2>[separador]<campo3>...[quebra de
254    * linha] No início de cada linha de apontamento deverá iniciar com tantos
255    * separadores quanto forem a quantidade de campos no cadastro de demandas.
256    * @param pRegDemanda
257    * @param pNumeroCamposDemanda
258    * @return
259    */
260   private String montaLinhasApontamentosComCamposOrdenados(RegDemandaRegd pRegDemanda, RegApontamentoRegda pRegApontamento, int pNumeroCamposDemanda) {
261 
262     String linhaRetorno = "";
263 
264     // Para cada apontamento monta o inicio da linha com os separadores
265     for (int i = 1; i <= pNumeroCamposDemanda; i++)
266       linhaRetorno += this.separadorCampos;
267 
268     // Monta os campos - em apontamento só existe campos fixos
269     linhaRetorno += pRegApontamento.getDataRegda() + this.separadorCampos;
270     linhaRetorno += pRegApontamento.getUsuarioUsu().getNomeUsu().replaceAll("\n", " ").replaceAll("\r", " ") + this.separadorCampos;
271     linhaRetorno += pRegApontamento.getInfoRegda().replaceAll("\n", " ").replaceAll("\r", " ") + this.separadorCampos;
272 
273     // Pega os anexos do apontamento
274     try {
275       String separadorAnexos = "";
276       ApontamentoAnexoDao anexoDao = new ApontamentoAnexoDao(request);
277       List<ApontamentoAnexo> anexosApontamento = anexoDao.getAnexosApontamentoRegda(pRegApontamento);
278       if (anexosApontamento != null && !anexosApontamento.isEmpty()) {
279         Iterator<ApontamentoAnexo> anexosApontamentosIt = anexosApontamento.iterator();
280         while (anexosApontamentosIt.hasNext()) {
281           ApontamentoAnexo anexoApto = (ApontamentoAnexo) anexosApontamentosIt.next();
282           linhaRetorno += separadorAnexos + anexoApto.getSrcAnexo();
283           separadorAnexos = this.separadorMultivalor;
284         }
285       }
286     } catch (ECARException e) {
287     }
288 
289     linhaRetorno = linhaRetorno.replaceAll("\n", " ").replaceAll("\r", " ");
290 
291     // Quebra de linha
292     linhaRetorno += "\n";
293 
294     return linhaRetorno;
295   }
296 
297 }