View Javadoc

1   /*
2    * Criado em 29/11/2004
3    */
4   package ecar.dao;
5   
6   import java.util.ArrayList;
7   import java.util.Date;
8   import java.util.HashSet;
9   import java.util.Iterator;
10  import java.util.List;
11  import java.util.Set;
12  
13  import javax.servlet.http.HttpServletRequest;
14  
15  import comum.database.Dao;
16  import comum.util.Pagina;
17  
18  import ecar.exception.ECARException;
19  import ecar.login.SegurancaECAR;
20  import ecar.pojo.AgendaEntidadesAgeent;
21  import ecar.pojo.EntidadeEnt;
22  import ecar.pojo.EstruturaEtt;
23  import ecar.pojo.EstruturaFuncaoEttf;
24  import ecar.pojo.EstruturaFuncaoEttfPK;
25  import ecar.pojo.FuncaoFun;
26  import ecar.pojo.TipoFuncAcompTpfa;
27  
28  /**
29   * @author felipev
30   */
31  public class EstruturaFuncaoDao extends Dao {
32    /*
33     * private EstruturaDao estruturaDao = null; private FuncaoDao funcaoDao =
34     * null;
35     */
36  
37    /**
38     * Construtor. Chama o Session factory do Hibernate
39     */
40    public EstruturaFuncaoDao(HttpServletRequest request) {
41      super();
42      this.request = request;
43      /*
44       * estruturaDao = new EstruturaDao(this.request); funcaoDao = new
45       * FuncaoDao(this.request);
46       */
47    }
48  
49    /**
50     * @param request
51     * @param listaEstrutura
52     * @param listaFuncao
53     * @throws ECARException
54     */
55    public void controlaListas(HttpServletRequest request, List listaEstrutura, List listaFuncao) throws ECARException {
56  
57      if (Pagina.getParam(request, "estruturaEtt") != null) {
58        listaFuncao.addAll(this.getFuncoes((EstruturaEtt) new EstruturaDao(request).buscar(EstruturaEtt.class, Long.valueOf(Pagina.getParam(request, "estruturaEtt")))));
59      }
60      else {
61        /* Lista de funções recebe todas as funções */
62        listaFuncao.addAll(new FuncaoDao(request).listar(FuncaoFun.class, new String[] { "nomeFun", "asc" }));
63      }
64  
65      if (Pagina.getParam(request, "funcaoFun") != null) {
66        listaEstrutura.addAll(this.getEstruturas((FuncaoFun) new FuncaoDao(request).buscar(FuncaoFun.class, Long.valueOf(Pagina.getParam(request, "funcaoFun")))));
67      }
68      else {
69        listaEstrutura.addAll(new EstruturaDao(request).listar(EstruturaEtt.class, new String[] { "nomeEtt", "asc" }));
70      }
71  
72    }
73  
74    public void setEstruturaFuncao(HttpServletRequest request, EstruturaFuncaoEttf estruturaFuncao, boolean usarGetParamStr) throws ECARException {
75      if (Pagina.getParam(request, "estruturaEtt") != null)
76        estruturaFuncao.setEstruturaEtt((EstruturaEtt) (new EstruturaDao(request).buscar(EstruturaEtt.class, Long.valueOf(Pagina.getParam(request, "estruturaEtt")))));
77      if (Pagina.getParam(request, "funcaoFun") != null)
78        estruturaFuncao.setFuncaoFun((FuncaoFun) new FuncaoDao(request).buscar(FuncaoFun.class, Long.valueOf(Pagina.getParam(request, "funcaoFun"))));
79  
80      if (usarGetParamStr) {
81        estruturaFuncao.setLabelEttf(Pagina.getParamStr(request, "labelEttf"));
82        estruturaFuncao.setDicaEttf(Pagina.getParamStr(request, "dicaEttf"));
83        estruturaFuncao.setIndListagemImpressaResEttf(Pagina.getParamOrDefault(request, "indListagemImpressaResEttf", Pagina.NAO));
84        estruturaFuncao.setIndListagemImpressCompEttf(Pagina.getParamOrDefault(request, "indListagemImpressCompEttf", Pagina.NAO));
85        estruturaFuncao.setIndRevisaoEttf(Pagina.getParamOrDefault(request, "indRevisaoEttf", Pagina.NAO));
86        estruturaFuncao.setIndPodeBloquearEttf(Pagina.getParamOrDefault(request, "indPodeBloquearEttf", Pagina.NAO));
87  
88      }
89      else {
90        estruturaFuncao.setLabelEttf(Pagina.getParam(request, "labelEttf"));
91        estruturaFuncao.setDicaEttf(Pagina.getParam(request, "dicaEttf"));
92        estruturaFuncao.setIndListagemImpressaResEttf(Pagina.getParam(request, "indListagemImpressaResEttf"));
93        estruturaFuncao.setIndListagemImpressCompEttf(Pagina.getParam(request, "indListagemImpressCompEttf"));
94        estruturaFuncao.setIndRevisaoEttf(Pagina.getParam(request, "indRevisaoEttf"));
95        estruturaFuncao.setIndPodeBloquearEttf(Pagina.getParam(request, "indPodeBloquearEttf"));
96      }
97  
98      if (Pagina.getParam(request, "seqApresentacaoTelaEttf") != null)
99        estruturaFuncao.setSeqApresentacaoTelaEttf(Integer.valueOf(Pagina.getParam(request, "seqApresentacaoTelaEttf")));
100     if (Pagina.getParam(request, "seqApresentacaoRelatorioEttf") != null)
101       estruturaFuncao.setSeqApresentacaoRelatorioEttf(Integer.valueOf(Pagina.getParam(request, "seqApresentacaoRelatorioEttf")));
102     if (Pagina.getParamStr(request, "documentacaoEttf") != null)
103       estruturaFuncao.setDocumentacaoEttf(Pagina.getParam(request, "documentacaoEttf"));
104     else
105       estruturaFuncao.setDocumentacaoEttf(null);
106   }
107 
108   /**
109    * Verificação das estruturas de acompanhementos que para quem o bloqueio foi
110    * liberado
111    * @param estrutFunc Função de Estrutura que recebe uma lista de Tipo de
112    *          Função de acompanhamento compermissão de editar funções mesmo
113    *          quando estas se encontram bloqueadas.
114    * @return Conjunto com a lista de tipo de acompanhamento
115    */
116   public Set setLimbTipoFuncAcompTpfa() {
117 
118     Set<TipoFuncAcompTpfa> set = new HashSet<TipoFuncAcompTpfa>();
119 
120     if (request.getParameterValues("limbTipoFuncAcompTpfa") != null) {
121       String strLibTipoFuncAcomp[] = request.getParameterValues("limbTipoFuncAcompTpfa");
122       Long codTpfa = null;// [] = new Long[strEntidades.length];
123 
124       try {
125         for (int i = 0; i < strLibTipoFuncAcomp.length; i++) {
126           codTpfa = Long.parseLong(strLibTipoFuncAcomp[i]);
127           TipoFuncAcompTpfa tipoFuncAcomp = (TipoFuncAcompTpfa) this.buscar(TipoFuncAcompTpfa.class, codTpfa);
128 
129           set.add(tipoFuncAcomp);
130         }// fim for
131       } catch (ECARException e) {
132         // e.printStackTrace();
133       }
134 
135     }// fim if
136 
137     return set;
138 
139   }
140 
141   /**
142    * Devolve uma lista com todas as funções vinculadas a uma estrutura
143    * @param estrutura
144    * @return List de FuncaoFun
145    */
146   public List getFuncoes(EstruturaEtt estrutura) {
147     List retorno = new ArrayList();
148     if (estrutura.getEstruturaFuncaoEttfs() != null) {
149       Iterator it = estrutura.getEstruturaFuncaoEttfs().iterator();
150       while (it.hasNext()) {
151         EstruturaFuncaoEttf estruturaFuncao = (EstruturaFuncaoEttf) it.next();
152         retorno.add(estruturaFuncao.getFuncaoFun());
153       }
154     }
155     return retorno;
156   }
157 
158   /**
159    * Devolve uma lista com todas as estruturas vinculadas a uma função
160    * @param estrutura
161    * @return List de FuncaoFun
162    */
163   public List getEstruturas(FuncaoFun funcao) {
164     List retorno = new ArrayList();
165     if (funcao.getEstruturaFuncaoEttfs() != null) {
166       Iterator it = funcao.getEstruturaFuncaoEttfs().iterator();
167       while (it.hasNext()) {
168         EstruturaFuncaoEttf estruturaFuncao = (EstruturaFuncaoEttf) it.next();
169         retorno.add(estruturaFuncao.getEstruturaEtt());
170       }
171     }
172     return retorno;
173   }
174 
175   /**
176    * Devolve um objeto EstruturaFuncao, utilizado para imprimir o Label da
177    * Função
178    * @param estrutura
179    * @param codFun (codAba)
180    * @return Obj EstruturaFuncao
181    * @throws ECARException
182    */
183   public EstruturaFuncaoEttf getLabelFuncao(EstruturaEtt estrutura, Long codFun) throws ECARException {
184     EstruturaFuncaoEttfPK chave = new EstruturaFuncaoEttfPK();
185     EstruturaFuncaoEttf estruturaFuncao = new EstruturaFuncaoEttf();
186 
187     chave.setCodEtt(estrutura.getCodEtt());
188     chave.setCodFun(codFun);
189     // System.out.println(estrutura.getCodEtt() + " " + codFun);
190     try {
191       estruturaFuncao = (EstruturaFuncaoEttf) buscar(EstruturaFuncaoEttf.class, chave);
192     } catch (ECARException e) {
193       if ("erro.objectNotFound".equals(e.getMessageKey())) {
194         return null;
195       }
196       throw new ECARException(e);
197     }
198     return estruturaFuncao;
199   }
200 
201   /**
202    * @author n/c
203    * @param estrutura
204    * @return String
205    * @throws ECARException
206    */
207   public String getLabelFuncaoFonteRecurso(EstruturaEtt estrutura) throws ECARException {
208     FuncaoFun funcao = new FuncaoFun();
209     funcao.setNomeFun("Fontes_Recursos");
210     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
211     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
212     try {
213       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
214     } catch (Exception e) {
215       this.logger.error(e);
216       if (funcao.getLabelPadraoFun() != null)
217         return f.getLabelPadraoFun();
218       else
219         return f.getNomeFun();
220     }
221 
222   }
223 
224   /**
225    * @author n/c
226    * @param estrutura
227    * @return String
228    * @throws ECARException
229    */
230   public String getLabelFuncaoRecurso(EstruturaEtt estrutura) throws ECARException {
231     FuncaoFun funcao = new FuncaoFun();
232     funcao.setNomeFun("Recursos");
233     // Pesquisa em ordem descendente para que Recursos venha antes de
234     // Fonte_recurso
235     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "desc" });
236     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
237     try {
238       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
239     } catch (Exception e) {
240       this.logger.error(e);
241       if (funcao.getLabelPadraoFun() != null)
242         return f.getLabelPadraoFun();
243       else
244         return f.getNomeFun();
245     }
246   }
247 
248   /**
249    * @author n/c
250    * @param estrutura
251    * @return string
252    * @throws ECARException
253    */
254   public String getLabelFuncaoAnexo(EstruturaEtt estrutura) throws ECARException {
255     FuncaoFun funcao = new FuncaoFun();
256     funcao.setNomeFun("Itens_de_Anexo");
257     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
258     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
259     try {
260       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
261     } catch (Exception e) {
262       this.logger.error(e);
263       if (funcao.getLabelPadraoFun() != null)
264         return f.getLabelPadraoFun();
265       else
266         return f.getNomeFun();
267     }
268   }
269 
270   /**
271    * @author n/c
272    * @param estrutura
273    * @return string
274    * @throws ECARException
275    */
276   public String getLabelFuncaoPontosCriticos(EstruturaEtt estrutura) throws ECARException {
277     FuncaoFun funcao = new FuncaoFun();
278     funcao.setNomeFun("Pontos_Criticos");
279     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
280     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
281     try {
282       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
283     } catch (Exception e) {
284       this.logger.error(e);
285       if (funcao.getLabelPadraoFun() != null)
286         return f.getLabelPadraoFun();
287       else
288         return f.getNomeFun();
289     }
290   }
291 
292   /**
293    * @author n/c
294    * @param estrutura
295    * @return boolean
296    * @throws ECARException
297    */
298   public boolean existeFuncaoPontosCriticos(EstruturaEtt estrutura) throws ECARException {
299     FuncaoFun funcao = new FuncaoFun();
300     funcao.setNomeFun("Pontos_Criticos");
301     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
302     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
303     boolean resultado = false;
304     try {
305       if (getLabelFuncao(estrutura, f.getCodFun()) != null) {
306         resultado = true;
307       }
308       return resultado;
309     } catch (ECARException e) {
310       this.logger.error(e);
311       return resultado;
312     }
313   }
314 
315   /**
316    * @author n/c
317    * @param estrutura
318    * @return boolean
319    * @throws ECARException
320    */
321   public boolean existeFuncaoAnexo(EstruturaEtt estrutura) throws ECARException {
322     FuncaoFun funcao = new FuncaoFun();
323     funcao.setNomeFun("Itens_de_Anexo");
324     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
325     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
326     boolean resultado = false;
327     try {
328       if (getLabelFuncao(estrutura, f.getCodFun()) != null) {
329         resultado = true;
330       }
331       return resultado;
332     } catch (ECARException e) {
333       this.logger.error(e);
334       return resultado;
335     }
336   }
337 
338   /**
339    * @author n/c
340    * @param estrutura
341    * @return String
342    * @throws ECARException
343    */
344   public String getLabelFuncaoCategoriaAnexo(EstruturaEtt estrutura) throws ECARException {
345     FuncaoFun funcao = new FuncaoFun();
346     funcao.setNomeFun("Categorias");
347     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
348     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
349     try {
350       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
351     } catch (Exception e) {
352       this.logger.error(e);
353       if (funcao.getLabelPadraoFun() != null)
354         return f.getLabelPadraoFun();
355       else
356         return f.getNomeFun();
357     }
358   }
359 
360   /**
361    * @author n/c
362    * @param estrutura
363    * @return String
364    * @throws ECARException
365    */
366   public String getLabelIndicadoresResultado(EstruturaEtt estrutura) throws ECARException {
367     FuncaoFun funcao = new FuncaoFun();
368     funcao.setNomeFun("Indicadores_Resultado");
369     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
370     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
371     try {
372       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
373     } catch (Exception e) {
374       this.logger.error(e);
375       if (funcao.getLabelPadraoFun() != null)
376         return f.getLabelPadraoFun();
377       else
378         return f.getNomeFun();
379     }
380   }
381 
382   /**
383    * @author n/c
384    * @param estrutura
385    * @return String
386    * @throws ECARException
387    */
388   public String getLabelOcorrencias(EstruturaEtt estrutura) throws ECARException {
389     FuncaoFun funcao = new FuncaoFun();
390     funcao.setNomeFun("Eventos");
391     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
392     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
393     try {
394       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
395     } catch (Exception e) {
396       this.logger.error(e);
397       if (funcao.getLabelPadraoFun() != null)
398         return f.getLabelPadraoFun();
399       else
400         return f.getNomeFun();
401     }
402   }
403 
404   /**
405    * @author n/c
406    * @param estrutura
407    * @return String
408    * @throws ECARException
409    */
410   public String getLabelQuantidadesPrevistas(EstruturaEtt estrutura) throws ECARException {
411     FuncaoFun funcao = new FuncaoFun();
412     funcao.setNomeFun("Quantidades_Previstas");
413     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
414     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
415     try {
416       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
417     } catch (Exception e) {
418       this.logger.error(e);
419       if (f.getLabelPadraoFun() != null)
420         return f.getLabelPadraoFun();
421       else
422         return f.getNomeFun();
423     }
424   }
425 
426   /**
427    * @author n/c
428    * @param estrutura
429    * @return String
430    * @throws ECARException
431    */
432   public String getLabelApontamentos(EstruturaEtt estrutura) throws ECARException {
433     FuncaoFun funcao = new FuncaoFun();
434     funcao.setNomeFun("Apontamentos");
435     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
436     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
437     try {
438       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
439     } catch (Exception e) {
440       this.logger.error(e);
441       if (funcao.getLabelPadraoFun() != null) {
442         return f.getLabelPadraoFun();
443       }
444       else {
445         return f.getNomeFun();
446       }
447     }
448   }
449 
450   public EstruturaFuncaoEttf getApontamentos(EstruturaEtt estrutura) throws ECARException {
451     FuncaoFun funcao = new FuncaoFun();
452     funcao.setNomeFun("Apontamentos");
453     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
454     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
455     try {
456       return getLabelFuncao(estrutura, f.getCodFun());
457     } catch (ECARException e) {
458       this.logger.error(e);
459       return null;
460     }
461   }
462 
463   public EstruturaFuncaoEttf getQuantidadesPrevistas(EstruturaEtt estrutura) throws ECARException {
464     FuncaoFun funcao = new FuncaoFun();
465     funcao.setNomeFun("Quantidades_Previstas");
466     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
467     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
468     try {
469       return getLabelFuncao(estrutura, f.getCodFun());
470     } catch (ECARException e) {
471       this.logger.error(e);
472       return null;
473     }
474   }
475 
476   public EstruturaFuncaoEttf getItensAnexo(EstruturaEtt estrutura) throws ECARException {
477     FuncaoFun funcao = new FuncaoFun();
478     funcao.setNomeFun("Itens_de_Anexo");
479     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
480     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
481     try {
482       return getLabelFuncao(estrutura, f.getCodFun());
483     } catch (ECARException e) {
484       this.logger.error(e);
485       return null;
486     }
487   }
488 
489   /**
490    * @author Milton Pereira, José André e Thaise Dantas [SUNNE-SERPRO]
491    * @param estrutura
492    * @return String
493    * @throws ECARException
494    */
495   public String getLabelFuncaoContasOrcamento(EstruturaEtt estrutura) throws ECARException {
496     FuncaoFun funcao = new FuncaoFun();
497     funcao.setNomeFun("Contas_do_Orcamento");
498     List pesquisa = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", "asc" });
499     FuncaoFun f = (FuncaoFun) pesquisa.iterator().next();
500     try {
501       return getLabelFuncao(estrutura, f.getCodFun()).getLabelEttf();
502     } catch (Exception e) {
503       this.logger.error(e);
504       if (funcao.getLabelPadraoFun() != null)
505         return f.getLabelPadraoFun();
506       else
507         return f.getNomeFun();
508     }
509   }
510 }