AgendaDao xref

View Javadoc

1   /*
2    * Created on 11/05/2005
3    */
4   package ecar.dao;
5   
6   import java.util.ArrayList;
7   import java.util.Calendar;
8   import java.util.Date;
9   import java.util.Iterator;
10  import java.util.List;
11  
12  import javax.servlet.http.HttpServletRequest;
13  
14  import org.hibernate.HibernateException;
15  import org.hibernate.Transaction;
16  
17  import comum.database.Dao;
18  import comum.util.Data;
19  import comum.util.Pagina;
20  
21  import ecar.exception.ECARException;
22  import ecar.login.SegurancaECAR;
23  import ecar.pojo.AgendaAge;
24  import ecar.pojo.AgendaEntidadesAgeent;
25  import ecar.pojo.AgendaOcorrenciaAgeo;
26  import ecar.pojo.EntidadeEnt;
27  import ecar.pojo.ItemEstruturaIett;
28  import ecar.pojo.SisAtributoSatb;
29  import ecar.pojo.UsuarioUsu;
30  
31  /**
32   * @author evandro
33   */
34  public class AgendaDao extends Dao {
35  
36    public static final String PRDC_UNICO = "U";
37    public static final String PRDC_SEMANAL = "S";
38    public static final String PRDC_QUINZENAL = "Q";
39    public static final String PRDC_MENSAL = "M";
40    public static final String PRDC_ANUAL = "A";
41    public static final String PRDC_OUTRO = "O";
42  
43    /**
44     * Construtor. Chama o Session factory do Hibernate
45     */
46    public AgendaDao(HttpServletRequest request) {
47      super();
48      this.request = request;
49    }
50  
51    /**
52     * Metodo para setar os valores no objeto Agenda
53     * @param campos
54     * @param agenda
55     * @throws ECARException
56     */
57    public void setAgenda(HttpServletRequest campos, AgendaAge agenda) throws ECARException {
58  
59      if (request.getSession().getAttribute("seguranca") != null)
60        agenda.setUsuarioUsu(((SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
61  
62      if (Pagina.getParamDataBanco(campos, "dataAge") != null)
63        agenda.setDataAge(Pagina.getParamDataBanco(campos, "dataAge"));
64      if (!Pagina.getParamStr(campos, "horaEventoAge").equals(""))
65        agenda.setHoraEventoAge(Integer.valueOf(Pagina.getParamStr(campos, "horaEventoAge")));
66      if (!Pagina.getParamStr(campos, "minutoEventoAge").equals(""))
67        agenda.setMinutoEventoAge(Integer.valueOf(Pagina.getParamStr(campos, "minutoEventoAge")));
68      if (Pagina.getParamDataBanco(campos, "dataLimiteAge") != null)
69        agenda.setDataLimiteAge(Pagina.getParamDataBanco(campos, "dataLimiteAge"));
70      if (!Pagina.getParamStr(campos, "eventoAge").equals(""))
71        agenda.setEventoAge(Pagina.getParamStr(campos, "eventoAge"));
72      if (!Pagina.getParamStr(campos, "localAge").equals(""))
73        agenda.setLocalAge(Pagina.getParamStr(campos, "localAge"));
74      if (!Pagina.getParamStr(campos, "descricaoAge").equals(""))
75        agenda.setDescricaoAge(Pagina.getParamStr(campos, "descricaoAge"));
76      // caso de checkbox
77      if (!Pagina.getParamStr(campos, "indAtivo").equals("")) {
78        agenda.setIndAtivoAge(Pagina.getParamStr(campos, "indAtivo"));
79      }
80      else {
81        agenda.setIndAtivoAge("N");
82      }
83  
84      if (!Pagina.getParamStr(campos, "nomeContato").equals(""))
85        agenda.setNomeContato(Pagina.getParamStr(campos, "nomeContato"));
86      if (!Pagina.getParamStr(campos, "telefoneContato").equals(""))
87        agenda.setTelefoneContato(Pagina.getParamStr(campos, "telefoneContato"));
88      if (!Pagina.getParamStr(campos, "orgaoContato").equals(""))
89        agenda.setOrgaoContato(Pagina.getParamStr(campos, "orgaoContato"));
90      if (!Pagina.getParamStr(campos, "comentario").equals(""))
91        agenda.setComentario(Pagina.getParamStr(campos, "comentario"));
92      // caso de checkbox
93      if (!Pagina.getParamStr(campos, "realizado").equals("")) {
94        agenda.setRealizado(Pagina.getParamStr(campos, "realizado"));
95      }
96      else {
97        agenda.setRealizado("N");
98      }
99  
100     if (!Pagina.getParamStr(campos, "exibirPortal").equals(""))
101       agenda.setExibirPortal(Pagina.getParamStr(campos, "exibirPortal"));
102     if (Pagina.getParamDataBanco(campos, "dataRealizado") != null)
103       agenda.setDataRealizado(Pagina.getParamDataBanco(campos, "dataRealizado"));
104 
105     if (!Pagina.getParamStr(campos, "codIett").equals("")) {
106       agenda.setItemEstruturaIett((ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamLong(request, "codIett"))));
107     }
108 
109     if (!Pagina.getParamStr(campos, "tipoEventoSatb").equals("")) {
110       agenda.setTipoEventoSatb((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(Pagina.getParamLong(request, "tipoEventoSatb"))));
111     }
112     else {
113       agenda.setTipoEventoSatb(null);
114     }
115   }
116 
117   /**
118    * Salva objeto em AgendaAge e gera ocorrências em AgendaOcorrenciaAgeo a
119    * partir da data até a data limite de acordo com a periodicidade escolhida.
120    * @param agenda
121    * @param request
122    * @throws ECARException
123    */
124   public void salvar(AgendaAge agenda, HttpServletRequest campos) throws ECARException {
125     AgendaOcorrenciaDao agendaOCDao = new AgendaOcorrenciaDao(campos);
126     Transaction tx = null;
127     try {
128       ArrayList objetos = new ArrayList();
129       super.inicializarLogBean();
130 
131       tx = session.beginTransaction();
132 
133       session.save(agenda);
134       objetos.add(agenda);
135 
136       ArrayList<AgendaEntidadesAgeent> listaAgendaEntidade = setAgendaEntidades(agenda);
137       for (AgendaEntidadesAgeent agendaEntidade : listaAgendaEntidade) {
138         session.save(agendaEntidade);
139       }
140 
141       if (!Pagina.getParamStr(campos, "opcaoPrdc").equals("")) {
142         String opcaoPrdc = Pagina.getParamStr(campos, "opcaoPrdc");
143 
144         if (PRDC_UNICO.equalsIgnoreCase(opcaoPrdc)) {
145           /* gera uma única ocorrência em AgendaOcorrencia igual a Agenda */
146           AgendaOcorrenciaAgeo agendaOC = new AgendaOcorrenciaAgeo();
147           agendaOCDao.setAgendaOcorrencia(agendaOC, agenda);
148           session.save(agendaOC);
149           objetos.add(agendaOC);
150         }
151         else if (PRDC_SEMANAL.equalsIgnoreCase(opcaoPrdc)) {
152           /*
153            * gera ocorrência(s) até a data limite, somente para dias da semana
154            * selecionados
155            */
156           /*
157            * (EX.: se SEG e QUA - são gerados em AgendaOcorrencia da data
158            * inicial até a data limite
159            */
160           /* todas as SEGs e QUAs) */
161 
162           AgendaOcorrenciaAgeo agendaOC = new AgendaOcorrenciaAgeo();
163           agendaOCDao.setAgendaOcorrencia(agendaOC, agenda);
164           // session.save(agendaOC);
165           // objetos.add(agendaOC);
166 
167           String[] diasSemana = campos.getParameterValues("diasSemanaPrdc");
168 
169           for (int i = 0; i < diasSemana.length; i++) {
170             Calendar data = Data.getGregorianCalendar(agenda.getDataAge());
171 
172             /* Calcular a diferença do dia da semana */
173             if (data.get(Calendar.DAY_OF_WEEK) != (Long.valueOf(diasSemana[i])).intValue()) {
174               /*
175                * Havendo diferença com o dia da semana selecionado verifica a
176                * diferença e soma encontrando o primeiro a partir do início
177                */
178               int difDiaSemana = (7 - data.get(Calendar.DAY_OF_WEEK)) + (Long.valueOf(diasSemana[i])).intValue();
179 
180               if (difDiaSemana > 7)
181                 difDiaSemana = difDiaSemana - 7;
182 
183               data.add(Calendar.DATE, difDiaSemana);
184             }
185             else {
186               /*
187                * Se mesmo dia da semana, é somado uma semana, pois já foi
188                * incluída a primera semana
189                */
190               data.add(Calendar.DATE, 7);
191             }
192 
193             while (data.before(Data.getGregorianCalendar(agenda.getDataLimiteAge())) || data.equals(Data.getGregorianCalendar(agenda.getDataLimiteAge()))) {
194               /* Para cada inclusão, instanciar um objeto */
195 
196               AgendaOcorrenciaAgeo agendaOCSemanal = new AgendaOcorrenciaAgeo();
197 
198               agendaOCDao.setAgendaOcorrencia(agendaOCSemanal, agenda);
199               agendaOCSemanal.setDataEventoAgeo(data.getTime());
200 
201               session.save(agendaOCSemanal);
202               objetos.add(agendaOCSemanal);
203 
204               data.add(Calendar.DATE, 7);
205             }
206           }
207         }
208         else if (PRDC_QUINZENAL.equalsIgnoreCase(opcaoPrdc)) {
209           /* gera ocorrência(s) até a data limite, de 14 em 14 dias, */
210           /* para que sempre seja o mesmo dia da semana */
211 
212           Calendar data = Data.getGregorianCalendar(agenda.getDataAge());
213 
214           while (data.before(Data.getGregorianCalendar(agenda.getDataLimiteAge())) || data.equals(Data.getGregorianCalendar(agenda.getDataLimiteAge()))) {
215             AgendaOcorrenciaAgeo agendaOC = new AgendaOcorrenciaAgeo();
216 
217             agendaOCDao.setAgendaOcorrencia(agendaOC, agenda);
218             agendaOC.setDataEventoAgeo(data.getTime());
219 
220             session.save(agendaOC);
221             objetos.add(agendaOC);
222 
223             data.add(Calendar.DATE, 14);
224           }
225         }
226         else if (PRDC_MENSAL.equalsIgnoreCase(opcaoPrdc)) {
227           /* gera ocorrência(s) até a data limite, soma 1 mês */
228 
229           Calendar data = Data.getGregorianCalendar(agenda.getDataAge());
230 
231           while (data.before(Data.getGregorianCalendar(agenda.getDataLimiteAge())) || data.equals(Data.getGregorianCalendar(agenda.getDataLimiteAge()))) {
232             AgendaOcorrenciaAgeo agendaOC = new AgendaOcorrenciaAgeo();
233 
234             agendaOCDao.setAgendaOcorrencia(agendaOC, agenda);
235             agendaOC.setDataEventoAgeo(data.getTime());
236 
237             session.save(agendaOC);
238             objetos.add(agendaOC);
239 
240             data.add(Calendar.MONTH, 1);
241           }
242         }
243         else if (PRDC_ANUAL.equalsIgnoreCase(opcaoPrdc)) {
244           /* gera ocorrência(s) até a data limite, soma 1 ano */
245 
246           Calendar data = Data.getGregorianCalendar(agenda.getDataAge());
247 
248           while (data.before(Data.getGregorianCalendar(agenda.getDataLimiteAge())) || data.equals(Data.getGregorianCalendar(agenda.getDataLimiteAge()))) {
249             AgendaOcorrenciaAgeo agendaOC = new AgendaOcorrenciaAgeo();
250 
251             agendaOCDao.setAgendaOcorrencia(agendaOC, agenda);
252             agendaOC.setDataEventoAgeo(data.getTime());
253 
254             session.save(agendaOC);
255             objetos.add(agendaOC);
256 
257             data.add(Calendar.YEAR, 1);
258           }
259         }
260         else if (PRDC_OUTRO.equalsIgnoreCase(opcaoPrdc)) {
261           /* gera ocorrência(s) até a data limite, soma X dias */
262 
263           Calendar data = Data.getGregorianCalendar(agenda.getDataAge());
264           int dias = Pagina.getParamInt(campos, "diasPrdc");
265 
266           while (data.before(Data.getGregorianCalendar(agenda.getDataLimiteAge())) || data.equals(Data.getGregorianCalendar(agenda.getDataLimiteAge()))) {
267             AgendaOcorrenciaAgeo agendaOC = new AgendaOcorrenciaAgeo();
268 
269             agendaOCDao.setAgendaOcorrencia(agendaOC, agenda);
270             agendaOC.setDataEventoAgeo(data.getTime());
271 
272             session.save(agendaOC);
273             objetos.add(agendaOC);
274 
275             data.add(Calendar.DATE, dias);
276           }
277         }
278       }
279 
280       tx.commit();
281 
282       if (super.logBean != null) {
283         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
284         super.logBean.setOperacao("INC");
285 
286         for (Iterator itObj = objetos.iterator(); itObj.hasNext();) {
287           super.logBean.setObj(itObj.next());
288           super.loggerAuditoria.info(logBean.toString());
289         }
290       }
291     } catch (HibernateException e) {
292       if (tx != null) {
293         try {
294           tx.rollback();
295         } catch (HibernateException r) {
296           this.logger.error(r);
297           throw new ECARException("erro.hibernateException");
298         }
299       }
300       this.logger.error(e);
301       throw new ECARException("erro.hibernateException");
302     }
303   }
304 
305   private ArrayList<AgendaEntidadesAgeent> setAgendaEntidades(AgendaAge agenda) throws ECARException {
306     ArrayList<AgendaEntidadesAgeent> lista = new ArrayList<AgendaEntidadesAgeent>();
307     // Salva entidades (atores) relacionadas com essa agenda
308     if (request.getParameterValues("codEnt") != null) {
309       String strEntidades[] = request.getParameterValues("codEnt");
310       Long codEntidade = null;// [] = new Long[strEntidades.length];
311 
312       for (int i = 0; i < strEntidades.length; i++) {
313         codEntidade = Long.parseLong(strEntidades[i]);
314 
315         AgendaEntidadesAgeent agendaEntidade = new AgendaEntidadesAgeent();
316         agendaEntidade.setAgendaAge(agenda);
317         agendaEntidade.setEntidadeEnt((EntidadeEnt) this.buscar(EntidadeEnt.class, codEntidade));
318         agendaEntidade.setDataInclusaoAgeent(new Date());
319         agendaEntidade.setUsuarioUsuManutencao(((SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
320         agendaEntidade.atribuirPKPai();
321         lista.add(agendaEntidade);
322       }// fim for
323     }// fim if
324     return lista;
325   }
326 
327   /**
328    * Método que exclui uma AgendaOcorrência, e sendo única exclui também Agenda
329    * Também ocorre a exclusão de uma Agenda inteira, com todas AgendaOcorrencia
330    * @param agenda
331    * @param agendaOC
332    * @param String excluir = ("todos" ou "único")
333    * @throws ECARException
334    */
335   public void excluir(AgendaAge agenda, AgendaOcorrenciaAgeo agendaOC, String excluir) throws ECARException {
336     if ("todos".equalsIgnoreCase(excluir)) {
337       if (contar(agenda.getDestaqueItemRelDtqirs()) > 0)
338         throw new ECARException("admPortal.agenda.exclusao.erro.destaqueItemRelDtqirs");
339       else
340         super.excluir(agenda);
341     }
342     else {
343       if (contar(agendaOC.getDestaqueItemRelDtqirs()) > 0)
344         throw new ECARException("admPortal.agenda.exclusao.erro.destaqueItemRelDtqirs");
345       else
346         super.excluir(agendaOC);
347     }
348   }
349 
350   /**
351    * Recebe um array de códigos de ItemEstruturaAcao e exclui os registro
352    * referenciados por estes códigos
353    * @param codigosParaExcluir
354    * @param codItemEstrutura
355    * @throws ECARException
356    */
357   public void excluir(String[] codigosParaExcluir, UsuarioUsu usuario) throws ECARException {
358     Transaction tx = null;
359 
360     try {
361       List<AgendaAge> objetos = new ArrayList();
362       super.inicializarLogBean();
363       tx = session.beginTransaction();
364 
365       for (int i = 0; i < codigosParaExcluir.length; i++) {
366         AgendaAge agenda = (AgendaAge) this.buscar(AgendaAge.class, Long.valueOf(codigosParaExcluir[i]));
367         agenda.setUsuarioUsu(usuario);
368 
369         session.delete(agenda);
370         objetos.add(agenda);
371       }
372 
373       tx.commit();
374 
375       if (super.logBean != null) {
376         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
377         super.logBean.setOperacao("EXC");
378         Iterator itObj = objetos.iterator();
379 
380         while (itObj.hasNext()) {
381           super.logBean.setObj(itObj.next());
382           super.loggerAuditoria.info(logBean.toString());
383         }
384       }
385     } catch (HibernateException e) {
386       if (tx != null)
387         try {
388           tx.rollback();
389         } catch (HibernateException r) {
390           this.logger.error(r);
391           throw new ECARException("erro.hibernateException");
392         }
393       this.logger.error(e);
394       throw new ECARException("erro.hibernateException");
395     }
396   }
397 
398   /**
399    * Método que altera uma AgendaOcorrência,
400    * @param agenda
401    * @param agendaOC
402    * @param String excluir = ("todos" ou "único")
403    * @throws ECARException
404    */
405   public void alterar(AgendaAge agenda) throws ECARException {
406     super.alterar(agenda);
407   }
408 
409   /**
410    * Método que altera uma Agenda de função de estrurara relacionada a 0:N
411    * entidades,
412    * @param agenda
413    * @param agendaOC
414    * @param String excluir = ("todos" ou "único")
415    * @throws ECARException
416    */
417   public void alterar(AgendaAge agenda, HttpServletRequest campos) throws ECARException {
418 
419     Transaction tx = null;
420 
421     try {
422       List objetos = new ArrayList();
423       super.inicializarLogBean();
424       tx = session.beginTransaction();
425 
426       this.setAgenda(campos, agenda);
427       session.update(agenda);
428 
429       objetos.add(agenda);
430 
431       if (agenda.getAgendaEntidadesAgeent() != null) {
432         Iterator itAgeEnt = agenda.getAgendaEntidadesAgeent().iterator();
433         while (itAgeEnt.hasNext()) {
434           AgendaEntidadesAgeent ageEnt = (AgendaEntidadesAgeent) itAgeEnt.next();
435           session.delete(ageEnt);
436           objetos.add(ageEnt);
437         }
438       }
439 
440       agenda.setAgendaEntidadesAgeent(null);
441       this.setAgenda(request, agenda);
442       ArrayList<AgendaEntidadesAgeent> listaAgendaEntidade = setAgendaEntidades(agenda);
443 
444       for (AgendaEntidadesAgeent agendaEntidade : listaAgendaEntidade) {
445         session.save(agendaEntidade);
446         objetos.add(agendaEntidade);
447       }
448 
449       tx.commit();
450 
451       // if (super.logBean != null) {
452       // super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
453       // super.logBean.setOperacao("INC_ALT_EXC");
454       // Iterator itObj = objetos.iterator();
455       //
456       // while (itObj.hasNext()) {
457       // super.logBean.setObj(itObj.next());
458       // super.loggerAuditoria.info(logBean.toString());
459       // }
460       // }
461 
462     } catch (HibernateException e) {
463       if (tx != null)
464         try {
465           tx.rollback();
466         } catch (HibernateException r) {
467           this.logger.error(r);
468           throw new ECARException("erro.hibernateException");
469         }
470       this.logger.error(e);
471       throw new ECARException("erro.hibernateException");
472     } catch (ECARException e) {
473       this.logger.error(e);
474       if (tx != null)
475         try {
476           tx.rollback();
477         } catch (HibernateException r) {
478           this.logger.error(r);
479           throw new ECARException("erro.hibernateException");
480         }
481       throw e;
482     }
483   }
484 
485   /**
486    * Retorna lista com Agendas ativas
487    * @return
488    * @throws ECARException
489    */
490   public List getAtivos() throws ECARException {
491     AgendaAge agenda = new AgendaAge();
492     agenda.setIndAtivoAge("S");
493     return super.pesquisar(agenda, new String[] { "descricaoAge", "asc" });
494   }
495 
496 }