View Javadoc

1   /*
2    * Criado em 29/04/2005
3    */
4   package ecar.dao;
5   
6   import java.io.File;
7   import java.util.ArrayList;
8   import java.util.HashSet;
9   import java.util.Iterator;
10  import java.util.List;
11  
12  import javax.servlet.ServletContext;
13  import javax.servlet.http.HttpServletRequest;
14  
15  import org.apache.commons.fileupload.FileItem;
16  import org.hibernate.HibernateException;
17  import org.hibernate.Query;
18  import org.hibernate.Transaction;
19  
20  import comum.database.Dao;
21  import comum.util.Data;
22  import comum.util.FileUpload;
23  import comum.util.Mensagem;
24  import comum.util.Pagina;
25  
26  import ecar.exception.ECARException;
27  import ecar.pojo.SegmentoAreaSgta;
28  import ecar.pojo.SegmentoLeiauteSgtl;
29  import ecar.pojo.SegmentoSgt;
30  import ecar.pojo.SisAtributoSatb;
31  import ecar.pojo.SisGrupoAtributoSga;
32  
33  /**
34   * @author evandro
35   * @author felipe
36   */
37  public class SegmentoDao extends Dao {
38    /**
39     * Construtor. Chama o Session factory do Hibernate
40     */
41    public SegmentoDao(HttpServletRequest request) {
42      super();
43      this.request = request;
44    }
45  
46    /**
47     * Salva um registro de segmento a partir de parâmetros recebidos por request
48     * por um formulário de Upload. Salva a coleção de tipos de acesso do
49     * segmento. Salva a imagem selecionada em disco.
50     * @param segmento
51     * @param campos
52     * @param pathRaiz
53     * @param pathRelativo
54     * @throws ECARException
55     */
56    public void salvar(SegmentoSgt segmento, List campos, String pathRaiz, String pathRelativo) throws ECARException {
57      Transaction tx = null;
58  
59      try {
60        ArrayList objetos = new ArrayList();
61  
62        super.inicializarLogBean();
63  
64        tx = session.beginTransaction();
65  
66        setSegmentoUpload(segmento, campos);
67        criarCollectionTipoAcesso(segmento, campos, null, true);
68        session.save(segmento);
69        objetos.add(segmento);
70  
71        /* grava a imagem e atualiza o segmento para vincular o nome da imagem */
72        uploadImagem(segmento, campos, pathRaiz, pathRelativo);
73        session.update(segmento);
74        objetos.add(segmento);
75  
76        tx.commit();
77  
78        if (super.logBean != null) {
79          super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
80          super.logBean.setOperacao("INC_ALT");
81          Iterator itObj = objetos.iterator();
82  
83          while (itObj.hasNext()) {
84            super.logBean.setObj(itObj.next());
85            super.loggerAuditoria.info(logBean.toString());
86          }
87        }
88      } catch (HibernateException e) {
89        if (tx != null)
90          try {
91            tx.rollback();
92          } catch (HibernateException r) {
93            this.logger.error(r);
94            throw new ECARException("erro.hibernateException");
95          }
96        this.logger.error(e);
97        throw new ECARException("erro.hibernateException");
98      }
99    }
100 
101   /**
102    * Exclui um registro de segmento. Exclui a imagem vinculada caso exista.
103    * @param segmento
104    * @param pathRaiz
105    * @throws ECARException
106    */
107   public void excluir(SegmentoSgt segmento, String pathRaiz) throws ECARException {
108     boolean excluir = true;
109     if (contar(segmento.getSegmentoCategoriaSgtcs()) > 0) {
110       excluir = false;
111       throw new ECARException("segmento.exclusao.erro.segmentoCategoriaSgtcs");
112     }
113     if (contar(segmento.getSegmentoItemSgtis()) > 0) {
114       excluir = false;
115       throw new ECARException("segmento.exclusao.erro.segmentoItemSgtis");
116     }
117 
118     if (excluir) {
119       if (segmento.getImagemSgt() != null) {
120         try {
121           if (FileUpload.apagarArquivo(FileUpload.getPathFisico(pathRaiz, segmento.getImagemSgt(), ""))) {
122             super.excluir(segmento);
123           }
124           else {
125             throw new ECARException("erro.excluirArquivo");
126           }
127         } catch (Exception e) {
128           this.logger.error(e);
129           throw new ECARException("erro.exception");
130         }
131       }
132       else
133         super.excluir(segmento);
134     }
135   }
136 
137   /**
138    * Altera um registro de segmento a partir de parâmetros recebidos por request
139    * por um formulário de Upload. Altera a coleção de tipos de acesso do
140    * segmento. Salva a imagem selecionada em disco e apaga a uma imagem
141    * existente anteriormente.
142    * @param segmento
143    * @param campos
144    * @param pathRaiz
145    * @param pathRelativo
146    * @throws ECARException
147    */
148   public void alterar(SegmentoSgt segmento, List campos, String pathRaiz, String pathRelativo) throws ECARException {
149 
150     String flagImagem = "";
151 
152     Transaction tx = null;
153 
154     try {
155       ArrayList objetos = new ArrayList();
156 
157       super.inicializarLogBean();
158 
159       tx = session.beginTransaction();
160 
161       if (("".equals(FileUpload.verificaValorCampo(campos, "imagemSgt"))) && (!"".equals(FileUpload.verificaValorCampo(campos, "imagem")))) {
162         if (segmento.getImagemSgt() != null) {
163 
164           if (!FileUpload.apagarArquivo(FileUpload.getPathFisico(pathRaiz, segmento.getImagemSgt(), ""))) {
165             throw new ECARException("erro.excluirArquivo");
166 
167           }
168         }
169 
170         flagImagem = "excluidaImagem";
171 
172       }
173 
174       setSegmentoUpload(segmento, campos);
175 
176       if ("excluidaImagem".equalsIgnoreCase(flagImagem)) {
177         segmento.setImagemSgt("");
178         session.save(segmento);
179         objetos.add(segmento);
180       }
181 
182       if ("".equals(FileUpload.verificaValorCampo(campos, "legendaImagemSgt"))) {
183         segmento.setImagemSgt("");
184         session.save(segmento);
185         objetos.add(segmento);
186       }
187 
188       criarCollectionTipoAcesso(segmento, campos, null, true);
189       uploadImagem(segmento, campos, pathRaiz, pathRelativo);
190       session.update(segmento);
191       objetos.add(segmento);
192 
193       tx.commit();
194 
195       if (super.logBean != null) {
196         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
197         super.logBean.setOperacao("INC_ALT");
198         Iterator itObj = objetos.iterator();
199 
200         while (itObj.hasNext()) {
201           super.logBean.setObj(itObj.next());
202           super.loggerAuditoria.info(logBean.toString());
203         }
204       }
205     } catch (Exception e) {
206       if (tx != null)
207         try {
208           tx.rollback();
209         } catch (HibernateException r) {
210           this.logger.error(r);
211           throw new ECARException("erro.hibernateException");
212         }
213       this.logger.error(e);
214       throw new ECARException("erro.hibernateException");
215     }
216   }
217 
218   /**
219    * Realiza o upload da imagem do Segmento. Seta no objeto segmento referência
220    * para tal imagem. Apaga uma imagem existente anteriormente em caso de
221    * alteração.
222    * @param segmento
223    * @param campos
224    * @param pathRaiz
225    * @param pathRelativo
226    * @throws ECARException
227    */
228   public void uploadImagem(SegmentoSgt segmento, List campos, String pathRaiz, String pathRelativo) throws ECARException {
229     try {
230       Iterator it = campos.iterator();
231       while (it.hasNext()) {
232         FileItem fileItem = (FileItem) it.next();
233         if (!fileItem.isFormField() && !"".equals(fileItem.getName())) {
234 
235           if (segmento.getImagemSgt() != null)
236             FileUpload.apagarArquivo(FileUpload.getPathFisico(pathRaiz, segmento.getImagemSgt(), ""));
237 
238           File arquivoGravado = FileUpload.salvarNoDisco(fileItem, FileUpload.getPathFisico(pathRaiz, pathRelativo, segmento.getCodSgt() + FileUpload.getNomeArquivo(fileItem)));
239           segmento.setImagemSgt(FileUpload.getPathFisico("", pathRelativo, segmento.getCodSgt() + FileUpload.getNomeArquivo(fileItem)));
240         }
241       }
242     } catch (Exception e) {
243       this.logger.error(e);
244       throw new ECARException(e);
245     }
246 
247   }
248 
249   /**
250    * A partir de dados passados por request popula um objeto SegmentoSgt
251    * @param segmento
252    * @param campos
253    * @param recuperarParametrosComoString indica se irá recuperar dados nulos
254    *          como String vazia
255    * @throws ECARException
256    */
257   public void setSegmento(SegmentoSgt segmento, HttpServletRequest campos, boolean recuperarParametrosComoString) throws ECARException {
258 
259     try {
260       if (!"".equals(Pagina.getParamStr(campos, "segmentoArea"))) {
261         segmento.setSegmentoAreaSgta((SegmentoAreaSgta) this.buscar(SegmentoAreaSgta.class, Long.valueOf(Pagina.getParamStr(campos, "segmentoArea"))));
262       }
263       if (!"".equals(Pagina.getParamStr(campos, "segmentoLeiauteSgtl"))) {
264         segmento.setSegmentoLeiauteSgtl((SegmentoLeiauteSgtl) this.buscar(SegmentoLeiauteSgtl.class, Long.valueOf(Pagina.getParamStr(campos, "segmentoLeiauteSgtl"))));
265       }
266       if (!"".equals(Pagina.getParamStr(campos, "sisGrupoAtributoEditorias"))) {
267         segmento.setSisGrupoAtributoSga((SisGrupoAtributoSga) this.buscar(SisGrupoAtributoSga.class, Long.valueOf(Pagina.getParamStr(campos, "sisGrupoAtributoEditorias"))));
268       }
269       if (recuperarParametrosComoString) {
270         segmento.setTituloSgt(Pagina.getParamStr(campos, "tituloSgt"));
271         segmento.setDescricaoSgt(Pagina.getParamStr(campos, "descricaoSgt"));
272         segmento.setLegendaImagemSgt(Pagina.getParamStr(campos, "legendaImagemSgt"));
273         segmento.setLinkPesquisaSgt(Pagina.getParamStr(campos, "linkPesquisaSgt"));
274         segmento.setIndMenuSgt(Pagina.getParamStr(campos, "indMenuSgt"));
275         segmento.setIndAtivoSgt(Pagina.getParamStr(campos, "indAtivoSgt"));
276         segmento.setIndUtilizTpAcessoSgt(Pagina.getParamStr(campos, "indUtilizTpAcessoSgt"));
277       }
278       else {
279         segmento.setTituloSgt(Pagina.getParam(campos, "tituloSgt"));
280         segmento.setDescricaoSgt(Pagina.getParam(campos, "descricaoSgt"));
281         segmento.setLegendaImagemSgt(Pagina.getParam(campos, "legendaImagemSgt"));
282         segmento.setLinkPesquisaSgt(Pagina.getParam(campos, "linkPesquisaSgt"));
283         segmento.setIndMenuSgt(Pagina.getParam(campos, "indMenuSgt"));
284         segmento.setIndAtivoSgt(Pagina.getParam(campos, "indAtivoSgt"));
285         segmento.setIndUtilizTpAcessoSgt(Pagina.getParam(campos, "indUtilizTpAcessoSgt"));
286       }
287       criarCollectionTipoAcesso(segmento, null, campos, false);
288     } catch (Exception e) {
289       this.logger.error(e);
290       throw new ECARException(e);
291     }
292 
293   }
294 
295   /**
296    * A partir de um List de campos obtidos na requsição de um formulário de
297    * upload popula um objeto SegmentoSgt
298    * @param segmento
299    * @param campos
300    * @throws ECARException
301    */
302   public void setSegmentoUpload(SegmentoSgt segmento, List campos) throws ECARException {
303 
304     try {
305       if (!"".equals(FileUpload.verificaValorCampo(campos, "segmentoArea"))) {
306         segmento.setSegmentoAreaSgta((SegmentoAreaSgta) this.buscar(SegmentoAreaSgta.class, Long.valueOf(FileUpload.verificaValorCampo(campos, "segmentoArea"))));
307       }
308       if (!"".equals(FileUpload.verificaValorCampo(campos, "segmentoLeiauteSgtl"))) {
309         segmento.setSegmentoLeiauteSgtl((SegmentoLeiauteSgtl) this.buscar(SegmentoLeiauteSgtl.class, Long.valueOf(FileUpload.verificaValorCampo(campos, "segmentoLeiauteSgtl"))));
310       }
311       if (!"".equals(FileUpload.verificaValorCampo(campos, "sisGrupoAtributoEditorias"))) {
312         segmento.setSisGrupoAtributoSga((SisGrupoAtributoSga) this.buscar(SisGrupoAtributoSga.class, Long.valueOf(FileUpload.verificaValorCampo(campos, "sisGrupoAtributoEditorias"))));
313       }
314       else {
315         segmento.setSisGrupoAtributoSga(null);
316       }
317       segmento.setTituloSgt(FileUpload.verificaValorCampo(campos, "tituloSgt"));
318       segmento.setDescricaoSgt(FileUpload.verificaValorCampo(campos, "descricaoSgt"));
319       segmento.setLegendaImagemSgt(FileUpload.verificaValorCampo(campos, "legendaImagemSgt"));
320       segmento.setLinkPesquisaSgt(FileUpload.verificaValorCampo(campos, "linkPesquisaSgt"));
321       segmento.setIndMenuSgt(FileUpload.verificaValorCampo(campos, "indMenuSgt"));
322       segmento.setIndAtivoSgt(FileUpload.verificaValorCampo(campos, "indAtivoSgt"));
323       segmento.setIndUtilizTpAcessoSgt(FileUpload.verificaValorCampo(campos, "indUtilizTpAcessoSgt"));
324 
325     } catch (Exception e) {
326       this.logger.error(e);
327       throw new ECARException(e);
328     }
329 
330   }
331 
332   /**
333    * Cria a coleção de atributos de Tipo de Acesso de Um Segmento
334    * @param segmento
335    * @param request
336    */
337   private void criarCollectionTipoAcesso(SegmentoSgt segmento, List campos, HttpServletRequest request, boolean usarFileUpload) throws ECARException {
338     try {
339       Object[] codigosTpAcesso;
340       if (usarFileUpload)
341         codigosTpAcesso = FileUpload.verificaValorCampoArray(campos, "sisAtributoSatb");
342       else
343         codigosTpAcesso = request.getParameterValues("sisAtributoSatb");
344 
345       if (codigosTpAcesso != null) {
346         segmento.setSegmentoTpAcessoSgttas(new HashSet());
347         for (int i = 0; i < codigosTpAcesso.length; i++) {
348           SisAtributoSatb atributo = (SisAtributoSatb) super.buscar(SisAtributoSatb.class, Long.valueOf(codigosTpAcesso[i].toString()));
349           if (segmento.getSegmentoTpAcessoSgttas() != null && !segmento.getSegmentoTpAcessoSgttas().contains(atributo))
350             segmento.getSegmentoTpAcessoSgttas().add(atributo);
351         }
352       }
353 
354     } catch (Exception e) {
355       this.logger.error(e);
356       throw new ECARException(e);
357     }
358   }
359 
360   /**
361    * Retorna uma List com todos as identificações dos Atributos que representam
362    * os Tipos de Acesso de um Segmento
363    * @param segmento
364    * @return
365    */
366   public List getTipoAcessoSegmentoById(SegmentoSgt segmento) {
367     List retorno = new ArrayList();
368     if (segmento.getSegmentoTpAcessoSgttas() != null && segmento.getSegmentoTpAcessoSgttas().size() > 0) {
369       Iterator it = segmento.getSegmentoTpAcessoSgttas().iterator();
370       while (it.hasNext()) {
371         SisAtributoSatb segmentoTpAcesso = (SisAtributoSatb) it.next();
372         retorno.add(segmentoTpAcesso.getCodSatb());
373       }
374     }
375     return retorno;
376   }
377 
378   /**
379    * Invoca o método pesquisar do Dao, retirando do resultado os Segmentos não
380    * fixos. e itera sobre o resultado para inicializar as Collections de Tipo de
381    * Acesso de Cada objeto retornado. Devolve um lista de segmentos livres de
382    * acordo com os parãmetros de o
383    * @param segmento
384    * @return
385    * @throws ECARException
386    */
387   public List pesquisar(SegmentoSgt segmento, ServletContext application) throws ECARException {
388 
389     List pesquisa = super.pesquisar(segmento, new String[] { "descricaoSgt", "asc" });
390 
391     pesquisa.retainAll(this.getSegmentosLivres(application));
392 
393     if (segmento.getSegmentoTpAcessoSgttas() != null) {
394       /*
395        * Percorre o resultado e retira dele todas os segmentos onde dentro da
396        * coleção de SegmentoTpAcessoSgttas não existam todos os atributos de
397        * TpAcessoSgttas passados no objeto de pesquisa
398        */
399       List atributosPesquisa = new ArrayList();
400       atributosPesquisa.addAll(segmento.getSegmentoTpAcessoSgttas());
401 
402       Iterator it = pesquisa.iterator();
403       while (it.hasNext()) {
404         List atributosResultado = new ArrayList();
405         Iterator itAtribResultado = ((SegmentoSgt) it.next()).getSegmentoTpAcessoSgttas().iterator();
406 
407         while (itAtribResultado.hasNext())
408           atributosResultado.add((SisAtributoSatb) itAtribResultado.next());
409 
410         if (!atributosResultado.containsAll(atributosPesquisa))
411           it.remove();
412       }
413     }
414 
415     if (pesquisa.size() > 0) {
416       Iterator it = pesquisa.iterator();
417       while (it.hasNext()) {
418         SegmentoSgt sgt = (SegmentoSgt) it.next();
419         sgt.getSegmentoTpAcessoSgttas().size();
420       }
421     }
422     return pesquisa;
423   }
424 
425   /**
426    * Pesquisa
427    * @param segmento
428    * @return List (pesquisa)
429    * @throws ECARException
430    */
431   public List pesquisar(SegmentoSgt segmento) throws ECARException {
432 
433     List pesquisa = super.pesquisar(segmento, new String[] { "descricaoSgt", "asc" });
434 
435     if (segmento.getSegmentoTpAcessoSgttas() != null) {
436       /*
437        * Percorre o resultado e retira dele todas os segmentos onde dentro da
438        * coleção de SegmentoTpAcessoSgttas não existam todos os atributos de
439        * TpAcessoSgttas passados no objeto de pesquisa
440        */
441       List atributosPesquisa = new ArrayList();
442       atributosPesquisa.addAll(segmento.getSegmentoTpAcessoSgttas());
443 
444       Iterator it = pesquisa.iterator();
445       while (it.hasNext()) {
446         List atributosResultado = new ArrayList();
447         Iterator itAtribResultado = ((SegmentoSgt) it.next()).getSegmentoTpAcessoSgttas().iterator();
448 
449         while (itAtribResultado.hasNext())
450           atributosResultado.add((SisAtributoSatb) itAtribResultado.next());
451 
452         if (!atributosResultado.containsAll(atributosPesquisa))
453           it.remove();
454       }
455     }
456 
457     if (pesquisa.size() > 0) {
458       Iterator it = pesquisa.iterator();
459       while (it.hasNext()) {
460         SegmentoSgt sgt = (SegmentoSgt) it.next();
461         sgt.getSegmentoTpAcessoSgttas().size();
462       }
463     }
464     return pesquisa;
465   }
466 
467   /**
468    * Retorna uma lista com os segmentos livres (diferente de itens fixos
469    * Perguntas Frequentes, Glossario, Artigo e Taxações) Utilizando arquivo de
470    * properties (admPortal.itensFixos)
471    * @return
472    * @throws ECARException
473    */
474   public List getSegmentosLivres(ServletContext application) throws ECARException {
475     try {
476       Mensagem properties = new Mensagem(application);
477       String select = "select segmento from SegmentoSgt segmento where not segmento.codSgt in (:msg)";
478       Query query = this.getSession().createQuery(select);
479       String[] msg = properties.getMensagem("admPortal.itensFixos").split(",");
480       List itens = new ArrayList();
481       for (int i = 0; i < msg.length; i++) {
482         if (!"".equals(msg[i])) {
483           itens.add(Long.valueOf(msg[i]));
484         }
485       }
486       query.setParameterList("msg", itens);
487 
488       return query.list();
489     } catch (HibernateException e) {
490       this.logger.error(e);
491       throw new ECARException(e);
492     }
493   }
494 
495   /**
496    * Retorna uma lista com os segmentos livres que possuam um grupo de atributos
497    * para editorias cadastrado ( código maior que 4 - diferente de Perguntas
498    * Frequentes, Glossario, Artigo e Taxações)
499    * @return
500    * @throws ECARException
501    */
502   public List getSegmentosLivresComGrupoDeAtributoParaEditorias(ServletContext application) throws ECARException {
503     try {
504       Mensagem properties = new Mensagem(application);
505       StringBuilder select = new StringBuilder("select segmento from SegmentoSgt segmento").append(" where not segmento.codSgt in (:msg)").append(" and segmento.sisGrupoAtributoSga is not null");
506 
507       Query query = this.getSession().createQuery(select.toString());
508       query.setString("msg", properties.getMensagem("admPortal.itensFixos"));
509       return query.list();
510     } catch (HibernateException e) {
511       this.logger.error(e);
512       throw new ECARException(e);
513     }
514   }
515 
516   /**
517    * @return List
518    * @throws ECARException
519    */
520   public List getAtivos() throws ECARException {
521     SegmentoSgt segmento = new SegmentoSgt();
522     segmento.setIndAtivoSgt("S");
523     return this.pesquisar(segmento);
524   }
525 }