ItemEstruturaContaOrcamentoDao xref

View Javadoc

1   /*
2    * Criado em 05/01/2005
3    */
4   package ecar.dao;
5   
6   import java.util.ArrayList;
7   import java.util.Date;
8   import java.util.Iterator;
9   import java.util.List;
10  
11  import javax.servlet.http.HttpServletRequest;
12  
13  import org.hibernate.Criteria;
14  import org.hibernate.HibernateException;
15  import org.hibernate.Query;
16  import org.hibernate.Transaction;
17  import org.hibernate.criterion.Restrictions;
18  
19  import comum.database.Dao;
20  import comum.database.HibernateUtil;
21  import comum.util.Data;
22  import comum.util.Pagina;
23  
24  import ecar.exception.ECARException;
25  import ecar.pojo.ConfigExecFinanCef;
26  import ecar.pojo.EfItemEstContaEfiec;
27  import ecar.pojo.EfItemEstRealizadoEfier;
28  import ecar.pojo.ExercicioExe;
29  import ecar.pojo.FonteRecursoFonr;
30  import ecar.pojo.ItemEstruturaIett;
31  import ecar.pojo.RecursoRec;
32  
33  /**
34   * @author felipev
35   */
36  public class ItemEstruturaContaOrcamentoDao extends Dao {
37  
38    /**
39     * Construtor. Chama o Session factory do Hibernate
40     */
41    public ItemEstruturaContaOrcamentoDao(HttpServletRequest request) {
42      super();
43      this.request = request;
44    }
45  
46    /**
47     * @param itemEstrutura
48     * @param codFonr
49     * @return List
50     * @throws ECARException
51     */
52    public List getAtivos(ItemEstruturaIett itemEstrutura, long codFonr) throws ECARException {
53      try {
54        // return
55        // this.getSession().createFilter(itemEstrutura.getEfItemEstContaEfiecs(),
56        // "where this.indAtivoEfiec = 'S' order by this.contaSistemaOrcEfiec asc").list();
57        return this.getSession().createFilter(itemEstrutura.getEfItemEstContaEfiecs(), "where this.indAtivoEfiec = 'S' and this.fonteRecursoFonr.codFonr = " + codFonr + " order by this.fonteRecursoFonr.sequenciaFonr asc, this.recursoRec.sequenciaRec asc").list();
58      } catch (HibernateException e) {
59        this.logger.error(e);
60        throw new ECARException("erro.hibernateException");
61      }
62  
63    }
64  
65    /**
66     * Verifica a possibilidade de inclusão de uma Conta para o item baseado na
67     * seguinte regra: Esta informação, mesmo que disponível para mais de um nível
68     * dentro da estrutura somente poderá ser incluída em um dos níveis dentro de
69     * um hierarquia de itens. Ou seja, se houver um ainformação incluída em um
70     * nível os itens "pais, avôs, etc" deste item e os "filhos, netos, etc" deste
71     * item não poderão ter informação nesta função
72     * @param itemEstrutura
73     * @return
74     */
75    public boolean verificaPossibilidadeInclusao(ItemEstruturaIett itemEstrutura) throws ECARException {
76      /*
77       * try{ EstruturaEtt estrutura = itemEstrutura.getEstruturaEtt(); Query
78       * queryEstrutura =this.getSession().createQuery(
79       * "select distinct conta.itemEstruturaIett.estruturaEtt " +
80       * " from EfItemEstContaEfiec conta"); EstruturaEtt estruturaNiveis =
81       * (EstruturaEtt) queryEstrutura.uniqueResult(); if(estruturaNiveis == null)
82       * return true; else{ if(estruturaNiveis.equals(estrutura)) return true; }
83       * return false; }catch(HibernateException e){ this.logger.error(e); throw
84       * new ECARException(e); }
85       */
86  
87      if (itemEstrutura.getEfItemEstContaEfiecs().size() > 0)
88        return true;
89  
90      ItemEstruturaDao itemDao = new ItemEstruturaDao(request);
91  
92      List lista = new ArrayList();
93      lista.addAll(itemDao.getAscendentes(itemEstrutura));
94      lista.addAll(itemDao.getDescendentes(itemEstrutura, true));
95  
96      Iterator it = lista.iterator();
97  
98      while (it.hasNext()) {
99        ItemEstruturaIett itemLista = (ItemEstruturaIett) it.next();
100 
101       if (itemLista.getEfItemEstContaEfiecs() != null && itemLista.getEfItemEstContaEfiecs().size() > 0)
102         return false;
103     }
104 
105     return true;
106 
107   }
108 
109   /**
110    * Método que gera os campos HTML para cadastro da Estrutura da Conta, baseado
111    * nos registros da tabela de Estrutura Contábil
112    * @param conta Se for informada uma conta, recupera os valores gravados para
113    *          esta conta
114    * @param disabled Indicativo mostrando se os campos devem estar desabilitados
115    *          ou não
116    * @param request Procura no request a informação de valores para cada campo
117    *          criado
118    * @return
119    * @throws ECARException
120    */
121   public static String geraHTMLCadastroEstruturaConta(String conta, boolean disabled, HttpServletRequest request) throws ECARException {
122     StringBuilder retorno = new StringBuilder();
123     String strConta = conta;
124     List estruturasContabil = new ConfigExecFinanDao(request).listar(ConfigExecFinanCef.class, new String[] { "seqApresentacaoCef", "asc" });
125     retorno.append("");
126     if (estruturasContabil != null) {
127       Iterator it = estruturasContabil.iterator();
128       String camposConta[] = new String[estruturasContabil.size()];
129       if (strConta != null)
130         camposConta = strConta.split(" ");
131 
132       int i = 0;
133       while (it.hasNext()) {
134         String strValor = "";
135         ConfigExecFinanCef estruturaContabil = (ConfigExecFinanCef) it.next();
136         /*
137          * este try-catch serve para aassegurar que não irá ocorrer uma exceção
138          * ao ler valores após ter sido criada uma nova estrutura contábil
139          */
140         try {
141           if (camposConta[i] != null)
142             strValor = camposConta[i];
143         } catch (ArrayIndexOutOfBoundsException ex) {
144 
145           strValor = "";
146         }
147 
148         StringBuilder buffer = new StringBuilder();
149         StringBuilder campoHidden = new StringBuilder();
150 
151         if ("validaCategoria".equals(estruturaContabil.getConfigTipoDadoCtd().getIdRotinaCtd())) {
152 
153           Query q = null;
154           q = HibernateUtil.currentSession().createQuery("from FonteRecursoFonr");
155           List<FonteRecursoFonr> categorias = (List<FonteRecursoFonr>) q.list();
156 
157           for (FonteRecursoFonr categoria : categorias) {
158             buffer.append(categoria.getSiglaFonr() + ",");
159           }
160 
161           String strBuffer = buffer.toString().substring(0, buffer.toString().lastIndexOf(","));
162 
163           campoHidden.append("<input type='hidden' name='categorias' id='categorias' value='" + strBuffer + "'>");
164 
165         }
166 
167         if ("validaFonte".equals(estruturaContabil.getConfigTipoDadoCtd().getIdRotinaCtd())) {
168 
169           Query q = null;
170           q = HibernateUtil.currentSession().createQuery("from RecursoRec");
171           List<RecursoRec> fontes = (List<RecursoRec>) q.list();
172 
173           for (RecursoRec fonte : fontes) {
174             buffer.append(fonte.getSiglaRec() + ",");
175           }
176 
177           String strBuffer = buffer.toString().substring(0, buffer.toString().lastIndexOf(","));
178           campoHidden.append("<input type='hidden' name='fontes' id='fontes' value='" + strBuffer + "'>");
179 
180         }
181 
182         if (!"".equals(Pagina.getParamStr(request, "e" + estruturaContabil.getCodCef())))
183           strValor = Pagina.getParamStr(request, "e" + estruturaContabil.getCodCef());
184         retorno.append("<div class=\"tabelaaolado\">").append(estruturaContabil.getLabelCef()).append("&nbsp;&nbsp;</br>").append("<input type=\"text\" size=\"").append(estruturaContabil.getNumCaracteresCef()).append("\" maxlength=\"").append(estruturaContabil.getNumCaracteresCef()).append("\" name=\"e").append(estruturaContabil.getCodCef()).append("\" value=\"").append(strValor).append("\"");
185         if (disabled)
186           retorno.append(" disabled ");
187         retorno.append("></div>");
188 
189         if (campoHidden.length() > 0) {
190           retorno.append(campoHidden.toString());
191         }
192 
193         i++;
194       }
195     }
196     return retorno.toString();
197   }
198 
199   /**
200    * Método que gera o label a ser usado na listagem de Contas do Orçamento,
201    * baseado nos registros da tabela de Estrutura Contábil
202    * @return String com código HTML
203    * @throws ECARException
204    */
205   public static String geraLabelCadastroEstruturaConta(HttpServletRequest request) throws ECARException {
206     StringBuilder retorno = new StringBuilder();
207     List estruturasContabil = new ConfigExecFinanDao(request).listar(ConfigExecFinanCef.class, new String[] { "seqApresentacaoCef", "asc" });
208     if (estruturasContabil != null) {
209       Iterator it = estruturasContabil.iterator();
210       while (it.hasNext()) {
211         ConfigExecFinanCef estruturaContabil = (ConfigExecFinanCef) it.next();
212         if (retorno.length() > 0)
213           retorno.append(" / ");
214         retorno.append(estruturaContabil.getLabelCef());
215       }
216     }
217     return retorno.toString();
218   }
219 
220   /**
221    * Método que gera validação para os campos do cadastro da Estrutura da Conta,
222    * baseado nos registros da tabela de Estrutura Contábil
223    * @return String com código JavaScript
224    * @throws ECARException
225    */
226   public static String geraValidacaoCadastroEstruturaConta(HttpServletRequest request) throws ECARException {
227     StringBuilder retorno = new StringBuilder();
228     List estruturasContabil = new ConfigExecFinanDao(request).listar(ConfigExecFinanCef.class, new String[] { "seqApresentacaoCef", "asc" });
229     if (estruturasContabil != null) {
230       Iterator it = estruturasContabil.iterator();
231       while (it.hasNext()) {
232 
233         ConfigExecFinanCef estruturaContabil = (ConfigExecFinanCef) it.next();
234 
235         retorno.append("if (!").append(estruturaContabil.getConfigTipoDadoCtd().getIdRotinaCtd()).append("(form.e").append(estruturaContabil.getCodCef()).append(",'").append(estruturaContabil.getLabelCef()).append("',true))\n").append(" return false;\n");
236       }
237     }
238     return retorno.toString();
239   }
240 
241   /**
242    * Exclusão de Contas do Orçamento de um Item Funcionamento: Verifica se a
243    * conta está cadastrada alguma vez em EF_Item_Est_Realizado_EFIER. Se não
244    * estivar reliza exclusão da conta do BD, se encontrar inativa a conta.
245    * @param codigosParaExcluir Array com os códigos das contas a serem excluídas
246    * @throws ECARException
247    */
248   public void excluir(String[] codigosParaExcluir) throws ECARException {
249     Transaction tx = null;
250 
251     try {
252       ArrayList objetos = new ArrayList();
253 
254       super.inicializarLogBean();
255 
256       tx = session.beginTransaction();
257 
258       for (int i = 0; i < codigosParaExcluir.length; i++) {
259         EfItemEstContaEfiec conta = (EfItemEstContaEfiec) this.buscar(EfItemEstContaEfiec.class, Long.valueOf(codigosParaExcluir[i]));
260         EfItemEstRealizadoEfier realizado = new EfItemEstRealizadoEfier();
261         realizado.setContaSistemaOrcEfier(conta.getContaSistemaOrcEfiec());
262         if (this.pesquisar(realizado, null).size() == 0) {
263           session.delete(conta);
264           objetos.add(conta);
265         }
266         else {
267           conta.setIndAtivoEfiec("N");
268           session.update(conta);
269           objetos.add(conta);
270         }
271       }
272 
273       tx.commit();
274 
275       if (super.logBean != null) {
276         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
277         super.logBean.setOperacao("ALT_EXC");
278         Iterator itObj = objetos.iterator();
279 
280         while (itObj.hasNext()) {
281           super.logBean.setObj(itObj.next());
282           super.loggerAuditoria.info(logBean.toString());
283         }
284       }
285     } catch (HibernateException e) {
286       if (tx != null)
287         try {
288           tx.rollback();
289         } catch (HibernateException r) {
290           this.logger.error(r);
291           throw new ECARException("erro.hibernateException");
292         }
293       this.logger.error(e);
294       throw new ECARException("erro.hibernateException");
295     }
296   }
297 
298   /**
299    * Grava uma conta fazendo uma verificação anteriormente para não permitir que
300    * a mesma conta (estrutura) seja gravada mais de uma vez para o mesmo item,
301    * fonte e recurso
302    * @param conta
303    * @throws ECARException
304    */
305   public void salvar(EfItemEstContaEfiec conta) throws ECARException {
306     EfItemEstContaEfiec contaAux = new EfItemEstContaEfiec();
307     // Esses campos nao podem repetir no registro
308     contaAux.setContaSistemaOrcEfiec(conta.getContaSistemaOrcEfiec());
309     contaAux.setExercicioExe(conta.getExercicioExe());
310     contaAux.setFonteRecursoFonr(conta.getFonteRecursoFonr());
311     contaAux.setRecursoRec(conta.getRecursoRec());
312     // contaAux.setItemEstruturaIett(conta.getItemEstruturaIett());
313     if (this.pesquisar(contaAux, null).size() > 0)
314       throw new ECARException("itemEstrutura.contaOrcamento.inclusao.erro.jaExiste");
315     else
316       super.salvar(conta);
317   }
318 
319   /**
320    * Grava uma lista de contas
321    * @author aleixo
322    * @since 0.1, 12/03/2007
323    * @version 0.2, 13/03/2007
324    * @param List<EfItemEstContaEfiec> contas
325    * @throws ECARException
326    */
327   public void salvar(List<EfItemEstContaEfiec> contas) throws ECARException {
328     Transaction tx = null;
329 
330     try {
331       tx = session.beginTransaction();
332       for (EfItemEstContaEfiec conta : contas) {
333         EfItemEstContaEfiec contaAux = new EfItemEstContaEfiec();
334         // Esses campos nao podem repetir no registro
335         contaAux.setContaSistemaOrcEfiec(conta.getContaSistemaOrcEfiec());
336         contaAux.setExercicioExe(conta.getExercicioExe());
337         contaAux.setFonteRecursoFonr(conta.getFonteRecursoFonr());
338         contaAux.setRecursoRec(conta.getRecursoRec());
339         contaAux.setItemEstruturaIett(conta.getItemEstruturaIett());
340 
341         // Se encontrar algum, deixar este item em particular e passar para o
342         // próximo, sem gerar exceção.
343         // Pq o item já existe.
344         if (!(this.pesquisar(contaAux, null).size() > 0))
345           session.save(conta);
346       }
347       tx.commit();
348 
349     } catch (HibernateException e) {
350       if (tx != null)
351         try {
352           tx.rollback();
353         } catch (HibernateException r) {
354           this.logger.error(r);
355           throw new ECARException("erro.hibernateException");
356         }
357       this.logger.error(e);
358       throw new ECARException("erro.hibernateException");
359     }
360   }
361 
362   /**
363    * Cria um objeto EfItemEstContaEfiec a partir de parâmetros passados no
364    * objeto request
365    * @param request
366    * @param conta
367    * @throws ECARException
368    */
369   public void setItemEstruturaContaOrcamento(HttpServletRequest request, EfItemEstContaEfiec conta) throws ECARException {
370     List estruturasContabil = new ConfigExecFinanDao(request).listar(ConfigExecFinanCef.class, new String[] { "seqApresentacaoCef", "asc" });
371     String estrutura = "";
372     if (estruturasContabil != null) {
373       Iterator it = estruturasContabil.iterator();
374       while (it.hasNext()) {
375         ConfigExecFinanCef estruturaContabil = (ConfigExecFinanCef) it.next();
376         if (estrutura.length() > 0)
377           estrutura += " ";
378         estrutura += Pagina.getParamStr(request, "e" + estruturaContabil.getCodCef());
379       }
380       /*
381        * Por causa destes ifs neste método os valores da Estrutura não são
382        * perdidos na alteração. Motivo: na tela de alterar conta todos os
383        * campos, com a exceção do Acumulado estão desabilitados e por isso não
384        * são enviados por request. Quando faço essa comparação, ao verificar que
385        * estes campos estão vazios, mantenho os valores existentes originalmente
386        * no objeto conta ( no caso são os valores que vieram do banco ) e por
387        * isso não são perdidos mesmo que venha vazio no request.
388        */
389       if (!"".equals(estrutura))
390         conta.setContaSistemaOrcEfiec(estrutura);
391     }
392     if (!"".equals(Pagina.getParamStr(request, "exercicioExe")))
393       conta.setExercicioExe((ExercicioExe) this.buscar(ExercicioExe.class, Long.valueOf(Pagina.getParamStr(request, "exercicioExe"))));
394     if (!"".equals(Pagina.getParamStr(request, "fonteRecursoFonr")))
395       conta.setFonteRecursoFonr((FonteRecursoFonr) this.buscar(FonteRecursoFonr.class, Long.valueOf(Pagina.getParamStr(request, "fonteRecursoFonr"))));
396     if (!"".equals(Pagina.getParamStr(request, "recursoRec")))
397       conta.setRecursoRec((RecursoRec) this.buscar(RecursoRec.class, Long.valueOf(Pagina.getParamStr(request, "recursoRec"))));
398     conta.setIndAcumuladoEfiec(Pagina.getParamStr(request, "indAcumuladoEfiec"));
399     conta.setItemEstruturaIett((ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIett"))));
400     conta.setIndAtivoEfiec("S");
401   }
402 
403   /**
404    * Devolve um ItemEstruturaConta a partir de um item, exercicio, fonte e
405    * recurso. Se não encontrar, devolve um ItemEstruturaConta vazio (somente com
406    * os parametros informados).
407    * @param ItemEstruturaIett item
408    * @param ExercicioExe exercicio
409    * @param FonteRecursoFonr fonte
410    * @param RecursoRec recurso
411    * @return EfItemEstContaEfiec
412    * @throws ECARException
413    */
414   public EfItemEstContaEfiec getItemEstruturaConta(ItemEstruturaIett item, ExercicioExe exercicio, FonteRecursoFonr fonte, RecursoRec recurso) throws ECARException {
415 
416     EfItemEstContaEfiec efiec = new EfItemEstContaEfiec();
417     List lista = new ArrayList();
418 
419     efiec.setItemEstruturaIett(item);
420     efiec.setExercicioExe(exercicio);
421     efiec.setFonteRecursoFonr(fonte);
422     efiec.setRecursoRec(recurso);
423 
424     lista = pesquisar(efiec, null);
425 
426     if (lista != null && lista.size() > 0)
427       return ((EfItemEstContaEfiec) lista.get(0));
428     else
429       return efiec;
430 
431   }
432 
433   /**
434    * Retorna as contas (registros) para o arquivo de exportação
435    * @param mesIni
436    * @param anoIni
437    * @param mesFim
438    * @param anoFim
439    * @return Lista de contas
440    */
441   public List getContasParaExportacao(String mesIni, String anoIni, String mesFim, String anoFim) throws ECARException, HibernateException {
442     try {
443 
444       int diaFinal = Data.getUltimoDiaMes(Data.parseDate("01/" + mesFim + "/" + anoFim));
445       Date dataInicial = Data.parseDate("01/" + mesIni + "/" + anoIni);
446       Date dataFinal = Data.parseDate(String.valueOf(diaFinal) + "/" + mesFim + "/" + anoFim);
447 
448       StringBuilder baseQuery = new StringBuilder("from EfItemEstContaEfiec conta ").append(" where (:dataIni >= conta.exercicioExe.dataInicialExe").append("   and :dataFim <= conta.exercicioExe.dataFinalExe)");
449 
450       Query objQuery = this.getSession().createQuery(baseQuery.toString());
451 
452       objQuery.setDate("dataIni", dataInicial);
453       objQuery.setDate("dataFim", dataFinal);
454 
455       return objQuery.list();
456     } catch (Exception e) {
457       this.logger.error(e);
458       throw new ECARException("integracaoFinanceira.exportarArquivo.consultaDados.erro");
459     }
460   }
461 
462   /**
463    * Método que verifica se já existe no banco algum registro que coincida com
464    * os novos dados do objeto a ser alterado. Caso exista algum registro que
465    * coincida então o método retornará false.
466    * @author carlos
467    * @return false
468    * @throws ECARException
469    * @throws HibernateException
470    */
471   public boolean consisteEfItemEstContaEfiec(EfItemEstContaEfiec obj) throws ECARException, HibernateException {
472 
473     boolean retorno = true;
474 
475     try {
476 
477       Criteria crits = session.createCriteria(EfItemEstContaEfiec.class);
478 
479       crits.add(Restrictions.ne("codEfiec", (obj.getCodEfiec() == null ? 0L : obj.getCodEfiec()))); // !=
480                                                                                                     // codEfiec
481       crits.add(Restrictions.eq("contaSistemaOrcEfiec", obj.getContaSistemaOrcEfiec()));
482       crits.add(Restrictions.eq("exercicioExe.codExe", obj.getExercicioExe().getCodExe()));
483       crits.add(Restrictions.eq("recursoRec.codRec", obj.getRecursoRec().getCodRec()));
484       crits.add(Restrictions.eq("fonteRecursoFonr.codFonr", obj.getFonteRecursoFonr().getCodFonr()));
485 
486       List<EfItemEstContaEfiec> lista = (List<EfItemEstContaEfiec>) crits.list();
487 
488       if (lista.size() > 0) {
489         retorno = false;
490       }
491 
492       return retorno;
493 
494     } catch (Exception e) {
495       this.logger.error(e);
496       throw new ECARException("erro.hibernateException");
497     }
498 
499   }
500 
501   /**
502    * Retorna um objeto EfItemEstContaEfiec caso exista, do contrário devolve
503    * null
504    * @author carlos
505    * @param conta
506    * @param exercicio
507    * @return EfItemEstContaEfiec
508    * @throws ECARException
509    * @throws HibernateException
510    */
511   public EfItemEstContaEfiec getEfItemEstContaEfiec(String conta, ExercicioExe exercicio) throws ECARException, HibernateException {
512 
513     EfItemEstContaEfiec retorno = null;
514 
515     try {
516       Criteria crits = session.createCriteria(EfItemEstContaEfiec.class);
517       crits.add(Restrictions.eq("contaSistemaOrcEfiec", conta));
518       crits.add(Restrictions.eq("exercicioExe.codExe", exercicio.getCodExe()));
519 
520       List<EfItemEstContaEfiec> lista = (List<EfItemEstContaEfiec>) crits.list();
521 
522       if (lista.size() > 0) {
523         retorno = lista.get(0);
524       }
525 
526     } catch (Exception e) {
527       this.logger.error(e);
528       throw new ECARException("erro.hibernateException");
529     }
530 
531     return retorno;
532   }
533 
534 }