/* * Copyright (C) 2007-2007 the GSAN - Sistema Integrado de Gestão de Serviços de Saneamento * * This file is part of GSAN, an integrated service management system for Sanitation * * GSAN is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License. * * GSAN is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA */ /* * GSAN - Sistema Integrado de Gestão de Serviços de Saneamento * Copyright (C) <2007> * Adriano Britto Siqueira * Alexandre Santos Cabral * Ana Carolina Alves Breda * Ana Maria Andrade Cavalcante * Aryed Lins de Araújo * Bruno Leonardo Rodrigues Barros * Carlos Elmano Rodrigues Ferreira * Cláudio de Andrade Lira * Denys Guimarães Guenes Tavares * Eduardo Breckenfeld da Rosa Borges * Fabíola Gomes de Araújo * Flávio Leonardo Cavalcanti Cordeiro * Francisco do Nascimento Júnior * Homero Sampaio Cavalcanti * Ivan Sérgio da Silva Júnior * José Edmar de Siqueira * José Thiago Tenório Lopes * Kássia Regina Silvestre de Albuquerque * Leonardo Luiz Vieira da Silva * Márcio Roberto Batista da Silva * Maria de Fátima Sampaio Leite * Micaela Maria Coelho de Araújo * Nelson Mendonça de Carvalho * Newton Morais e Silva * Pedro Alexandre Santos da Silva Filho * Rafael Corrêa Lima e Silva * Rafael Francisco Pinto * Rafael Koury Monteiro * Rafael Palermo de Araújo * Raphael Veras Rossiter * Roberto Sobreira Barbalho * Rodrigo Avellar Silveira * Rosana Carvalho Barbosa * Sávio Luiz de Andrade Cavalcante * Tai Mu Shih * Thiago Augusto Souza do Nascimento * Tiago Moreno Rodrigues * Vivianne Barbosa Sousa * * Este programa é software livre; você pode redistribuí-lo e/ou * modificá-lo sob os termos de Licença Pública Geral GNU, conforme * publicada pela Free Software Foundation; versão 2 da * Licença. * Este programa é distribuído na expectativa de ser útil, mas SEM * QUALQUER GARANTIA; sem mesmo a garantia implícita de * COMERCIALIZAÇÃO ou de ADEQUAÇÃO A QUALQUER PROPÓSITO EM * PARTICULAR. Consulte a Licença Pública Geral GNU para obter mais * detalhes. * Você deve ter recebido uma cópia da Licença Pública Geral GNU * junto com este programa; se não, escreva para Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA * 02111-1307, USA. */ package gcom.interceptor; import gcom.seguranca.acesso.Operacao; import gcom.seguranca.acesso.OperacaoEfetuada; import gcom.seguranca.acesso.usuario.Usuario; import gcom.seguranca.acesso.usuario.UsuarioAcao; import gcom.seguranca.acesso.usuario.UsuarioAcaoUsuarioHelper; import gcom.seguranca.transacao.AlteracaoTipo; import gcom.seguranca.transacao.ControladorTransacaoLocal; import gcom.seguranca.transacao.ControladorTransacaoLocalHome; import gcom.seguranca.transacao.FiltroTabela; import gcom.seguranca.transacao.FiltroTabelaColuna; import gcom.seguranca.transacao.Tabela; import gcom.seguranca.transacao.TabelaColuna; import gcom.seguranca.transacao.TabelaLinhaAlteracao; import gcom.seguranca.transacao.TabelaLinhaColunaAlteracao; import gcom.util.ConstantesJNDI; import gcom.util.ControladorException; import gcom.util.ControladorUtilLocal; import gcom.util.ControladorUtilLocalHome; import gcom.util.ControleAlteracaoColecao; import gcom.util.ErroRepositorioException; import gcom.util.HibernateUtil; import gcom.util.RepositorioUtilHBM; import gcom.util.ServiceLocator; import gcom.util.ServiceLocatorException; import gcom.util.SistemaException; import gcom.util.Util; import gcom.util.filtro.Filtro; import gcom.util.filtro.ParametroSimples; import gcom.util.filtro.ParametroSimplesColecao; import java.io.Serializable; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Collection; import java.util.Date; import java.util.Iterator; import java.util.Map; import java.util.Vector; import javax.ejb.CreateException; import org.hibernate.CallbackException; import org.hibernate.EntityMode; import org.hibernate.Interceptor; import org.hibernate.LazyInitializationException; import org.hibernate.Transaction; import org.hibernate.metadata.ClassMetadata; import org.hibernate.type.Type; public class Interceptador implements Interceptor { private static Interceptador interceptor; public static Interceptador getInstancia() { if (interceptor == null) { interceptor = new Interceptador(); } return interceptor; } private Interceptador() { } /** * Retorna o valor de controladorTarifaSocial * * @return O valor de controladorTarifaSocial */ private ControladorTransacaoLocal getControladorTransacao() { ControladorTransacaoLocalHome localHome = null; ControladorTransacaoLocal local = null; ServiceLocator locator = null; try { locator = ServiceLocator.getInstancia(); localHome = (ControladorTransacaoLocalHome) locator.getLocalHome(ConstantesJNDI.CONTROLADOR_TRANSACAO_SEJB); local = localHome.create(); return local; } catch (CreateException e) { throw new SistemaException(e); } catch (ServiceLocatorException e) { throw new SistemaException(e); } } /** * Retorna o valor de controladorUtil * * @return O valor de controladorUtil */ private ControladorUtilLocal getControladorUtil() { ControladorUtilLocalHome localHome = null; ControladorUtilLocal local = null; ServiceLocator locator = null; try { locator = ServiceLocator.getInstancia(); localHome = (ControladorUtilLocalHome) locator.getLocalHome(ConstantesJNDI.CONTROLADOR_UTIL_SEJB); local = localHome.create(); return local; } catch (CreateException e) { throw new SistemaException(e); } catch (ServiceLocatorException e) { throw new SistemaException(e); } } /** * Recebe uma coleção de objetos do tipo Tabelalinhacolunaalteracao para serem adicionados * como filhos de uma tabelalinhaalteraco do tipo do objeto transacao (novo) passado * @param novo * @param operacaoEfetuada * @param usuariosAcao * @param tabelaLinhaColunaAlteracoes * @throws SecurityException * @throws NoSuchMethodException * @throws IllegalArgumentException * @throws IllegalAccessException * @throws InvocationTargetException * @throws ControladorException */ private void salvarModificacao(ObjetoTransacao novo, OperacaoEfetuada operacaoEfetuada, Collection usuariosAcao, Collection tabelaLinhaColunaAlteracoes, int tipoAlteracao) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, ControladorException { String nomeTabela = HibernateUtil.getNameTable(novo.getClass()); FiltroTabela filtroTabela = new FiltroTabela(); filtroTabela.adicionarParametro(new ParametroSimples(FiltroTabela.NOME,nomeTabela)); Collection coll = getControladorUtil().pesquisar(filtroTabela,Tabela.class.getSimpleName()); Tabela tabela = null; if (coll != null && !coll.isEmpty()) { tabela = (Tabela) coll.iterator().next(); } else { return; /* * Foi acordado retirar a inclusão automática de tabelas e colunas não encontradas * Francisco Nascimento, 05/03/08 * tabela = new Tabela(); tabela.setNomeTabela(nomeTabela); tabela.setDescricao(nomeTabela); tabela.setUltimaAlteracao(new Date(System.currentTimeMillis())); this.getControladorUtil().inserir(tabela); */ } AlteracaoTipo alteracaoTipo = new AlteracaoTipo(); alteracaoTipo.setId(tipoAlteracao); TabelaLinhaAlteracao tabelaLinhaAlteracao = new TabelaLinhaAlteracao(); tabelaLinhaAlteracao.setUltimaAlteracao(new Date(System.currentTimeMillis())); if (novo.getId2() != null) tabelaLinhaAlteracao.setId2(novo.getId2()); tabelaLinhaAlteracao.setTabela(tabela); tabelaLinhaAlteracao.setAlteracaoTipo(alteracaoTipo); Integer[] ids = getIds(novo); if (ids != null && ids.length > 0) { tabelaLinhaAlteracao.setId1(ids[0]); } if (ids != null && ids.length > 1) { tabelaLinhaAlteracao.setId2(ids[1]); } Iterator it = tabelaLinhaColunaAlteracoes.iterator(); while (it.hasNext()) { TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = (TabelaLinhaColunaAlteracao) it.next(); FiltroTabelaColuna filtroTabelaColuna = new FiltroTabelaColuna(); filtroTabelaColuna.adicionarParametro(new ParametroSimples(FiltroTabelaColuna.TABELA_ID, tabela.getId())); filtroTabelaColuna.adicionarParametro(new ParametroSimples(FiltroTabelaColuna.COLUNA, tabelaLinhaColunaAlteracao.getTabelaColuna().getColuna())); coll = this.getControladorUtil().pesquisar(filtroTabelaColuna,TabelaColuna.class.getSimpleName()); TabelaColuna tabelaColuna = null; if (coll != null && !coll.isEmpty()) { tabelaColuna = (TabelaColuna) coll.iterator().next(); } else { System.out.println("Coluna nao encontrada: " + tabelaLinhaColunaAlteracao.getTabelaColuna().getColuna()); continue; /* * Foi acordado retirar a inclusão automática de tabelas e colunas não encontradas * Francisco Nascimento, 05/03/08 * * tabelaColuna = new TabelaColuna(); tabelaColuna.setColuna(tabelaLinhaColunaAlteracao.getTabelaColuna().getColuna()); tabelaColuna.setDescricaoColuna(tabelaLinhaColunaAlteracao.getTabelaColuna().getColuna()); tabelaColuna.setTabela(tabela); tabelaColuna.setUltimaAlteracao(new Date(System.currentTimeMillis())); Integer idTabelaColuna = (Integer) this.getControladorUtil().inserir(tabelaColuna); tabelaColuna.setId(idTabelaColuna); // inserindo a ordem de exibicao desta tabela coluna OperacaoOrdemExibicao ordemColuna = new OperacaoOrdemExibicao(); ordemColuna.setComp_id(new OperacaoOrdemExibicaoPK(new Integer(operacaoEfetuada.getOperacao().getId()), tabela.getId())); ordemColuna.setTabelaColuna(tabelaColuna); this.getControladorUtil().inserir(ordemColuna); */ } tabelaLinhaColunaAlteracao.setTabelaColuna(tabelaColuna); } this.getControladorTransacao().inserirOperacaoEfetuada(usuariosAcao, operacaoEfetuada,tabelaLinhaAlteracao, tabelaLinhaColunaAlteracoes); this.salvarTabelaLinhaAlteracaoPrincipal(operacaoEfetuada, novo); } public void verificarObjetoAlterado(Object arg0,String[] colecaoNomesAtributos) { if (arg0 instanceof ObjetoTransacao) { ObjetoTransacao objetoTransacao = (ObjetoTransacao) arg0; // verifica se a classe possui controle de registrar transacao if (!objetoTransacao.temControleAlteracao()){ return; } Filtro filtro = objetoTransacao.retornaFiltroRegistroOperacao(); if (objetoTransacao.getIdAntigo() != null){ filtro.getParametros().clear(); if (objetoTransacao.getIdAntigo() instanceof ObjetoGcom){ filtro.adicionarParametro(new ParametroSimplesColecao( objetoTransacao.retornaCamposChavePrimaria()[0],objetoTransacao.getIdAntigo())); } else { filtro.adicionarParametro(new ParametroSimples( objetoTransacao.retornaCamposChavePrimaria()[0],objetoTransacao.getIdAntigo())); } } try { Collection coll = RepositorioUtilHBM.getInstancia().pesquisar(filtro, objetoTransacao.getClass().getName()); if (coll.iterator().hasNext()) { ObjetoTransacao antigo = (ObjetoTransacao) coll.iterator() .next(); if ((antigo.getUltimaAlteracao() != null) && (objetoTransacao.getUltimaAlteracao() == null || antigo .getUltimaAlteracao().getTime() != objetoTransacao .getUltimaAlteracao().getTime())) { // throw new // IllegalArgumentException(" Data diferente."); } // Para os dados adicionais sera utilizado o objeto antigo, // pois // é garantido que os campos estão com valores boolean houveAlteracao = objetoTransacao .getOperacaoEfetuada().preencherDadosAdicionais( antigo); Collection tabelaLinhaColunaAlteracoes = compareObjetoTransacao( objetoTransacao, antigo, colecaoNomesAtributos); if (tabelaLinhaColunaAlteracoes != null && !tabelaLinhaColunaAlteracoes.isEmpty()) { String idPrincipal = objetoTransacao .getOperacaoEfetuada().getIdObjetoPrincipal() + ""; // Adicionando uma linha com a descricao do objeto, caso // esta descricao não seja vazia String[] keys = antigo.retornaCamposChavePrimaria(); for (int i = 0; keys != null && i < keys.length; i++) { String id = keys[i]; String descricaoVelho = consultarDescricao(antigo); String descricaoNovo = consultarDescricao(objetoTransacao); if (!(descricaoVelho.equals("") && descricaoNovo .equals("")) && !descricaoVelho.equals(idPrincipal)) { TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = gerarTabelaLinhaColunaAlteracao( id, objetoTransacao.getTipoAtributo(id), descricaoNovo, descricaoVelho); if (tabelaLinhaColunaAlteracao != null) tabelaLinhaColunaAlteracoes .add(tabelaLinhaColunaAlteracao); } break; } salvarModificacao(objetoTransacao, objetoTransacao.getOperacaoEfetuada(), objetoTransacao.getUsuarioAcaoUsuarioHelp(), tabelaLinhaColunaAlteracoes, AlteracaoTipo.ALTERACAO); } else { if (houveAlteracao) { if (objetoTransacao.getOperacaoEfetuada().getId() != null) { getControladorUtil().atualizar( objetoTransacao.getOperacaoEfetuada()); } } } } } catch (IllegalArgumentException e) { throw e; } catch (Exception e) { e.printStackTrace(); // caso tenha acontecido algum problema na consulta do objeto ao // banco. // throw new IllegalArgumentException(" Não pode consultar o // objeto transaço do banco. msn: " + e.getMessage()); } } } public void verificarObjetoAlterado(Object velho, Object novo) { if (velho instanceof ObjetoTransacao && novo instanceof ObjetoTransacao) { ObjetoTransacao objVelho = (ObjetoTransacao) velho; ObjetoTransacao objNovo = (ObjetoTransacao) novo; // verifica se a classe possui controle de registrar transacao if (objVelho !=null && !objVelho.temControleAlteracao()){ return; } // Para os dados adicionais sera utilizado o objeto antigo, pois // é garantido que os campos estão com valores objNovo.getOperacaoEfetuada().preencherDadosAdicionais(objVelho); Collection tabelaLinhaColunaAlteracoes = compareObjetoTransacao( objNovo, objVelho , objVelho.retornarAtributosSelecionadosRegistro()); if (tabelaLinhaColunaAlteracoes != null && !tabelaLinhaColunaAlteracoes.isEmpty()) { try { salvarModificacao(objNovo,objNovo.getOperacaoEfetuada(), objNovo.getUsuarioAcaoUsuarioHelp(), tabelaLinhaColunaAlteracoes, AlteracaoTipo.ALTERACAO); } catch (Exception e) { e.printStackTrace(); } } } } /** * Método que percorre os atribuitos do objeto velho e compara os com o do * objeto novo. Em busca de registrar atributos diferetes. * * @param novo - * ObjetoTransacao * @param velho - * ObjetoTransacao */ public Collection compareObjetoTransacao(ObjetoTransacao novo, ObjetoTransacao velho,String [] colecaoNomesAtributos) { Collection tabelaLinhaColunaAlteracoes = new Vector(); //Class classe = velho.getClass(); Method metodo = null; String nomeMetodo; String[] atributosRegistro = null; OperacaoEfetuada operacaoGeral = null; Collection usuariosAcao = null; if (novo != null) { atributosRegistro = novo.retornarAtributosSelecionadosRegistro(); operacaoGeral = novo.getOperacaoEfetuada(); usuariosAcao = novo.getUsuarioAcaoUsuarioHelp(); } else { atributosRegistro = velho.retornarAtributosSelecionadosRegistro(); operacaoGeral = velho.getOperacaoEfetuada(); usuariosAcao = velho.getUsuarioAcaoUsuarioHelp(); } //Alteração refeferente a CRC2511 - Registrar transação //para atualizaçõa de um campo apenas, o CPF do cliente //em Efetuar Parcelamento de Débitos //Anderson Italo/Francisco Nascimento //data:13/07/2009 //anteriormente continha o código do trecho comentado //if (atributosRegistro != null){ // colecaoNomesAtributos = atributosRegistro; //} if (atributosRegistro != null && (colecaoNomesAtributos != null && colecaoNomesAtributos.length >= atributosRegistro.length) || colecaoNomesAtributos == null){ colecaoNomesAtributos = atributosRegistro; } //fim alteração for (int i = 0; i < colecaoNomesAtributos.length; i++) { nomeMetodo = "get"; Object[] args = {colecaoNomesAtributos[i]}; Class[] tipos = {String.class}; try { Object retornoMetodoVelho = null; Object retornoMetodoNovo = null; // invocando o metodo do objeto velho para pegar o retorno if (velho != null) { metodo = velho.getClass().getMethod(nomeMetodo, tipos); retornoMetodoVelho = metodo.invoke(velho,args); if (retornoMetodoVelho != null && retornoMetodoVelho .getClass().getName().contains("Enhancer")){ Filtro filtro = velho.retornaFiltroRegistroOperacao(); filtro.adicionarParametro(new ParametroSimples("id", velho.get("id"))); Collection coll; try { coll = RepositorioUtilHBM.getInstancia().pesquisar(filtro, velho.getClass().getName()); velho = (ObjetoTransacao) Util.retonarObjetoDeColecao(coll); } catch (ErroRepositorioException e) { System.out.println(e.getMessage()); } retornoMetodoVelho = metodo.invoke(velho,args); } } if (novo != null) { metodo = novo.getClass().getMethod(nomeMetodo, tipos); retornoMetodoNovo = metodo.invoke(novo, args); } Object retorno = retornoMetodoVelho != null ? retornoMetodoVelho : retornoMetodoNovo; // verifica se o retorno eh do tipo conhecido if ((retorno instanceof ObjetoGcom) || (metodo.getReturnType().isPrimitive()) || (retorno instanceof Short) || (retorno instanceof Byte) || (retorno instanceof Character) || (retorno instanceof Integer) || (retorno instanceof Long) || (retorno instanceof Double) || (retorno instanceof Float) || (retorno instanceof String) || (retorno instanceof Boolean) || (retorno instanceof BigDecimal) || (retorno instanceof Date) || (retorno instanceof Collection)) { Collection auxAlteracoes = new Vector (); verificarDiferencaAtributo(auxAlteracoes, colecaoNomesAtributos[i], novo, retornoMetodoNovo, velho, retornoMetodoVelho, operacaoGeral, usuariosAcao, false); tabelaLinhaColunaAlteracoes.addAll(auxAlteracoes); } } catch (IllegalArgumentException e) { e.printStackTrace(); // e.printStackTrace(); // nunca entra aqui // excecao levantada quando o metodo invocado nao existe no // objeto passado // o metodo invocado foi pego da lista do objeto que se // deseja utilizar } catch (IllegalAccessException e) { e.printStackTrace(); // e.printStackTrace(); // nunca entra aqui // excecao levantada quando o metodo invocado nao existe no // objeto passado // o metodo invocado foi pego da lista do objeto que se // deseja utilizar } catch (InvocationTargetException e) { e.printStackTrace(); // e.printStackTrace(); // nunca entra aqui // excecao levantada quando o metodo invocado nao existe no // objeto passado // o metodo invocado foi pego da lista do objeto que se // deseja utilizar } catch (SecurityException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (ControladorException e) { e.printStackTrace(); } } return tabelaLinhaColunaAlteracoes; } /** * Método que verifica se existe diferenca entre os atributos, chama o * criadaor de TabelaLinhaColunaAlteracao e adiciona na collecao passada. * * @param nomeMetodo * @param nomeAtributo Nome do atributo que será verificado * @param novo Objeto novo que contém tal atributo * @param retornoMetodoNovo Valor novo deste atributo * @param velho Objeto velho que contém tal atributo * @param retornoMetodoVelho Valor velho deste atributo * @throws SecurityException * @throws NoSuchMethodException * @throws IllegalArgumentException * @throws IllegalAccessException * @throws InvocationTargetException * @throws ControladorException */ private void verificarDiferencaAtributo( Collection tabelaLinhaColunaAlteracoes, String nomeAtributo, ObjetoTransacao novo, Object retornoMetodoNovo, ObjetoTransacao velho, Object retornoMetodoVelho, OperacaoEfetuada operacaoEfetuada, Collection usuarios, boolean itemDeColecao) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, ControladorException { // if ocorre quando o retorno do metodo for um outro objeto do sistema e // forem alterados de um pra outro // exemplo quando vc tem um combo e vc tinha um objeto e selecionou // outro if (retornoMetodoVelho instanceof ObjetoTransacao || retornoMetodoNovo instanceof ObjetoTransacao) { // Caso o objetoGcom não tenha o Annotation 'ControleAlteracao', // é suficiente verificar se houve mudança de identificadores ObjetoTransacao gcomVelho = (ObjetoTransacao) retornoMetodoVelho; ObjetoTransacao gcomNovo = (ObjetoTransacao) retornoMetodoNovo; if (gcomNovo != null && gcomVelho != null) { gcomVelho = consultarObjetoCarregandoAtributo(gcomVelho); // pegar os ids e verificar se todos sao iguais // Caso o objeto tenha vários id (chave composta), o campo que será registrado // será a primeira chave, então para definir qual o campo que se quer salvar // altere o método retornaCamposChavePrimaria, definindo como o primeiro elemento // do array de keys, o campo que se queira deixar registrado. String[] keys = gcomVelho.retornaCamposChavePrimaria(); for (int i = 0; keys != null && i < keys.length; i++) { String id = keys[i]; String nomeMetodoKey = "get" + id.substring(0, 1).toUpperCase() + id.substring(1, id.length()); Method metodoNovo = gcomNovo.getClass().getMethod(nomeMetodoKey, (Class[])null); Object retornoKeyNovo = metodoNovo.invoke(gcomNovo, (Object[])null); Method metodoVelho = gcomVelho.getClass().getMethod(nomeMetodoKey,(Class[]) null); Object retornoKeyVelho = metodoVelho.invoke(gcomVelho, (Object[])null); // Ambos diferentes de null => alteracao if (retornoKeyNovo != null && retornoKeyVelho != null){ String descricaoVelho = consultarDescricao(gcomVelho); String descricaoNovo = consultarDescricao(gcomNovo); // Se os ids forem diferentes,primeiro registra-se o ID com o valor da descricao do objeto if (!retornoKeyVelho.equals(retornoKeyNovo)) { TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = gerarTabelaLinhaColunaAlteracao(nomeAtributo, novo.getTipoAtributo(nomeAtributo),descricaoNovo, descricaoVelho); if (tabelaLinhaColunaAlteracao != null) tabelaLinhaColunaAlteracoes.add(tabelaLinhaColunaAlteracao); } // Verificando se os atributos deste atributo deverá ser anasalido (recursivamente) // quando o getdescricaoParaRegistraTRansacao retorna "" é pq deve entrar no objeto pra // percorrer os campos if (gcomVelho.temControleAlteracao() // && (descricaoVelho.equals("") && descricaoNovo.equals("")) ){ // Entrando na classe deste atributo para analisar se houve alteração em seus atributos Collection alteracoes = compareObjetoTransacao(gcomNovo, gcomVelho, null); if (alteracoes != null && !alteracoes.isEmpty()){ TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = gerarTabelaLinhaColunaAlteracao( id, retornoMetodoNovo.getClass(),descricaoNovo, descricaoVelho); if (tabelaLinhaColunaAlteracao != null && tabelaLinhaColunaAlteracoes.isEmpty()){ alteracoes.add(tabelaLinhaColunaAlteracao); } tabelaLinhaColunaAlteracoes.addAll(alteracoes); } } } } // else ocorre quando o retono do metodo for um outro objeto do // sistema e forem alterados de um pra null ou de // null pra um // exemplo quando vc tem um pop up e vc setou pra null // ou vc tinha um null e vc escolheu um } else if ((retornoMetodoNovo != null && retornoMetodoVelho == null) || (retornoMetodoNovo == null && retornoMetodoVelho != null)) { // pegando os nomes dos ids String[] keys = null; if (gcomNovo != null){ keys = gcomNovo.retornaCamposChavePrimaria(); } else { keys = gcomVelho.retornaCamposChavePrimaria(); } for (int i = 0; keys != null && i < keys.length; i++) { // pra cada id pega o metodo String id = keys[i]; String descricaoVelho = null; String descricaoNovo = null; Class classe; if (gcomNovo != null) { descricaoNovo = consultarDescricao((ObjetoGcom)retornoMetodoNovo); } else { descricaoVelho = consultarDescricao((ObjetoGcom)retornoMetodoVelho); } String nomeCampo = ""; if (itemDeColecao){ nomeCampo = id; if (gcomNovo != null){ classe = gcomNovo.getClass(); } else { classe = gcomVelho.getClass(); } } else { nomeCampo = nomeAtributo; if (novo != null){ classe = novo.getClass(); } else { classe = velho.getClass(); } } TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = gerarTabelaLinhaColunaAlteracao(nomeCampo, classe,descricaoNovo, descricaoVelho); if (tabelaLinhaColunaAlteracao != null){ tabelaLinhaColunaAlteracoes.add(tabelaLinhaColunaAlteracao); if ((gcomVelho != null && gcomVelho.temControleAlteracao()) || (gcomNovo != null && gcomNovo.temControleAlteracao())){ if (gcomVelho != null){ Filtro filtro = gcomVelho.retornaFiltroRegistroOperacao(); try { Collection coll = RepositorioUtilHBM.getInstancia().pesquisar(filtro, gcomVelho.getClass().getName()); Iterator iter = coll.iterator(); if (iter.hasNext()){ gcomVelho = (ObjetoTransacao) iter.next(); } } catch (ErroRepositorioException e) { e.printStackTrace(); } } Collection alteracoes = compareObjetoTransacao(gcomNovo, gcomVelho, null); if (alteracoes != null && !alteracoes.isEmpty()){ tabelaLinhaColunaAlteracoes.addAll(alteracoes); } } } if ((gcomVelho != null && gcomVelho.temControleAlteracao()) || (gcomNovo != null && gcomNovo.temControleAlteracao())){ if (gcomVelho != null){ gcomVelho = consultarObjetoCarregandoAtributo(gcomVelho); } Collection alteracoes = compareObjetoTransacao(gcomNovo, gcomVelho, null); if (alteracoes != null && !alteracoes.isEmpty()){ tabelaLinhaColunaAlteracoes.addAll(alteracoes); } } } } } else if (retornoMetodoNovo instanceof Collection || retornoMetodoVelho instanceof Collection){ ControleAlteracaoColecao controle = ControleAlteracaoColecao.gerarControle( (Collection) retornoMetodoVelho, (Collection) retornoMetodoNovo); if (!controle.getAlteradas().isEmpty()){ for (Iterator iter = controle.getAlteradas().keySet().iterator(); iter .hasNext();) { Object elementAntes = iter.next(); Object elementDepois = controle.getAlteradas().get(elementAntes); Collection alteracoes = new Vector(); verificarDiferencaAtributo(alteracoes, nomeAtributo, novo, elementDepois, velho, elementAntes, operacaoEfetuada, usuarios, true); if (alteracoes != null && !alteracoes.isEmpty()){ salvarModificacao((ObjetoTransacao)elementDepois, operacaoEfetuada, usuarios, alteracoes, AlteracaoTipo.ALTERACAO); } } } if (!controle.getAdicionadas().isEmpty()){ for (Iterator iter = controle.getAdicionadas().iterator(); iter .hasNext();) { Object elementDepois = iter.next(); Collection alteracoes = new Vector(); verificarDiferencaAtributo(alteracoes, nomeAtributo, novo, elementDepois, velho, null, operacaoEfetuada, usuarios ,true); if (alteracoes != null && !alteracoes.isEmpty()){ salvarModificacao((ObjetoTransacao)elementDepois, operacaoEfetuada, usuarios, alteracoes, AlteracaoTipo.INCLUSAO); } } } if (!controle.getRemovidas().isEmpty()){ for (Iterator iter = controle.getRemovidas().iterator(); iter .hasNext();) { ObjetoTransacao elementAntes = (ObjetoTransacao) iter.next(); Collection alteracoes = new Vector(); verificarDiferencaAtributo(alteracoes, nomeAtributo, novo, null, velho, elementAntes, operacaoEfetuada, usuarios, true); elementAntes.setId2(novo.getId2()); if (alteracoes != null && !alteracoes.isEmpty()){ salvarModificacao(elementAntes, operacaoEfetuada, usuarios, alteracoes, AlteracaoTipo.EXCLUSAO); } } } } else { if (retornoMetodoNovo != null && retornoMetodoVelho != null) { if (!retornoMetodoNovo.equals(retornoMetodoVelho)) { TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = gerarTabelaLinhaColunaAlteracao(nomeAtributo, novo.getClass(),retornoMetodoNovo, retornoMetodoVelho); if (tabelaLinhaColunaAlteracao != null) tabelaLinhaColunaAlteracoes.add(tabelaLinhaColunaAlteracao); } // se o novo for diferente de null e velho for igual a null } else if ((retornoMetodoNovo != null && retornoMetodoVelho == null) || (retornoMetodoNovo == null && retornoMetodoVelho != null)) { Class classe = null; if (novo != null){ classe = novo.getClass(); } else { classe = velho.getClass(); } TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = gerarTabelaLinhaColunaAlteracao(nomeAtributo, classe, retornoMetodoNovo, retornoMetodoVelho); if (tabelaLinhaColunaAlteracao != null){ tabelaLinhaColunaAlteracoes.add(tabelaLinhaColunaAlteracao); } } } } public static ObjetoTransacao consultarObjetoCarregandoAtributo(ObjetoTransacao obj){ Filtro filtro = obj.retornaFiltroRegistroOperacao(); try { Collection coll = RepositorioUtilHBM.getInstancia().pesquisar(filtro, obj.getClass().getName()); Iterator iter = coll.iterator(); if (iter.hasNext()){ obj = (ObjetoTransacao) iter.next(); } } catch (ErroRepositorioException e) { e.printStackTrace(); } return obj; } /** * Método que cria uma TabelaLinhaColunaAlteracao * * @param nomeAtributo * @param classe * @param valorNovo * @param valorVelho * @throws NoSuchMethodException * @throws SecurityException * @throws InvocationTargetException * @throws IllegalAccessException * @throws IllegalArgumentException */ private TabelaLinhaColunaAlteracao gerarTabelaLinhaColunaAlteracao( String nomeAtributo, Class classe, Object valorNovo, Object valorVelho) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = null; // Dividir nomeAtributo pelo . e passar o ultimo valor para o proximo metodo int indiceUltimoPonto = nomeAtributo.lastIndexOf("."); if (indiceUltimoPonto != -1){ nomeAtributo = nomeAtributo.substring(indiceUltimoPonto + 1); } String nomeColuna = HibernateUtil.getNameColumn(classe, nomeAtributo); if (valorVelho == null) { valorVelho = ""; } if (valorNovo == null){ valorNovo = ""; } if (nomeColuna != null && !(valorVelho.equals("") && valorNovo.equals(""))) { TabelaColuna tabelaColuna = new TabelaColuna(); tabelaColuna.setColuna(nomeColuna); tabelaColuna.setDescricaoColuna(nomeColuna); tabelaLinhaColunaAlteracao = new TabelaLinhaColunaAlteracao(); tabelaLinhaColunaAlteracao.setTabelaColuna(tabelaColuna); tabelaLinhaColunaAlteracao.setConteudoColunaAnterior(valorVelho); tabelaLinhaColunaAlteracao.setConteudoColunaAtual(valorNovo); tabelaLinhaColunaAlteracao.setUltimaAlteracao(new Date(System.currentTimeMillis())); } return tabelaLinhaColunaAlteracao; } /** * Método que intercepta o save do hibernte utilizado pra registrar a * operacao * * @author Thiago Toscano * @date 25/03/2006 * * @param arg0 * objeto a ser salvo * @param arg1 * a chame primaria do objeto a ser salvo * @param arg2 * array de todos os valores do objeto * @param arg3 * array dos nomes de as propriedades do objeto * @param arg4 * array dos tipos das propriedades do objeto * @return * @throws CallbackException */ public boolean onSave(Object arg0, Serializable arg1, Object[] arg2,String[] arg3, Type[] arg4) throws CallbackException { translate(arg0, arg1, arg2, arg3, arg4); if (arg0 instanceof ObjetoTransacao) { ObjetoTransacao objetoTransacao = (ObjetoTransacao) arg0; if (objetoTransacao.getUsuarioAcaoUsuarioHelp() == null || objetoTransacao.getUsuarioAcaoUsuarioHelp().isEmpty()) { return true;// throw new // CallbackException("atencao.usuario.vazia"); } if (objetoTransacao.getOperacaoEfetuada() == null) { return true;// throw new // CallbackException("atencao.operacaoEfetuada.vazia"); } if (objetoTransacao.getOperacaoEfetuada().getOperacao() == null) { return true;// throw new // CallbackException("atencao.operacao.vazia"); } registrarInclusao(arg0, arg3); } return true; } private void registrarInclusao(Object obj, String[] arg){ if (obj instanceof ObjetoTransacao){ ObjetoTransacao objetoTransacao = (ObjetoTransacao) obj; // verifica se a classe possui controle de registrar transacao if (!objetoTransacao.temControleAlteracao()){ return; } if (objetoTransacao.getIdAntigo() == null){ try { String nomeTabela = HibernateUtil.getNameTable(objetoTransacao.getClass()); FiltroTabela filtroTabela = new FiltroTabela(); filtroTabela.adicionarParametro(new ParametroSimples(FiltroTabela.NOME, nomeTabela)); Collection coll = getControladorUtil().pesquisar(filtroTabela,Tabela.class.getSimpleName()); Tabela tabela = null; if (coll != null && !coll.isEmpty()) { tabela = (Tabela) coll.iterator().next(); } else { return; /* * Foi acordado retirar a inclusão automática de tabelas e colunas não encontradas * Francisco Nascimento, 05/03/08 * tabela = new Tabela(); tabela.setNomeTabela(nomeTabela); tabela.setDescricao(nomeTabela); tabela.setUltimaAlteracao(new Date(System.currentTimeMillis())); this.getControladorUtil().inserir(tabela); */ } objetoTransacao.getOperacaoEfetuada().preencherDadosAdicionais(objetoTransacao); AlteracaoTipo alteracaoTipo = new AlteracaoTipo(); alteracaoTipo.setId(AlteracaoTipo.INCLUSAO); TabelaLinhaAlteracao tabelaLinhaAlteracao = new TabelaLinhaAlteracao(); tabelaLinhaAlteracao.setUltimaAlteracao(new Date(System.currentTimeMillis())); if (objetoTransacao.getId2() != null) tabelaLinhaAlteracao.setId2(objetoTransacao.getId2()); tabelaLinhaAlteracao.setTabela(tabela); tabelaLinhaAlteracao.setAlteracaoTipo(alteracaoTipo); Collection collTabelaLinhaColunaAlteracao = new ArrayList(); // Adicionando uma linha com a descricao do objeto, caso esta descricao não seja vazia String[] keys = objetoTransacao.retornaCamposChavePrimaria(); for (int i = 0; keys != null && i < keys.length; i++) { String id = keys[i]; //String nomeMetodoKey = "get" + id.substring(0, 1).toUpperCase() + id.substring(1, id.length()); //Method metodoNovo = objetoTransacao.getClass().getMethod(nomeMetodoKey, (Class[])null); //Object retornoKeyNovo = metodoNovo.invoke(objetoTransacao, (Object[])null); String descricaoNovo = consultarDescricao(objetoTransacao); if (!descricaoNovo.equals("")){ TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = gerarTabelaLinhaColunaAlteracao( id, objetoTransacao.getTipoAtributo(id),descricaoNovo, ""); if (tabelaLinhaColunaAlteracao != null) tabelaLinhaColunaAlteracao.setTabelaLinhaAlteracao(tabelaLinhaAlteracao); // Pesquisa a Tabelacoluna TabelaColuna tabelaColuna = gerarTabelaColuna(tabela, id, objetoTransacao); tabelaLinhaColunaAlteracao.setTabelaColuna(tabelaColuna); collTabelaLinhaColunaAlteracao.add(tabelaLinhaColunaAlteracao); } break; } collTabelaLinhaColunaAlteracao.addAll(gerarTabelaLinhaColunaAlteracaoInclusaoOuExclusao(true, false, objetoTransacao, tabelaLinhaAlteracao)); // fim: adicionando descricao como alteracao Integer[] ids = getIds(objetoTransacao); if (ids != null && ids.length > 0) { tabelaLinhaAlteracao.setId1(ids[0]); } if (ids != null && ids.length > 1) { tabelaLinhaAlteracao.setId2(ids[1]); } if (objetoTransacao.getOperacaoEfetuada().getArgumentoValor() <= 0){ Object objId = objetoTransacao.get("id"); if (objId instanceof Integer){ objetoTransacao.getOperacaoEfetuada().setArgumentoValor((Integer) objId); } else { } } this.getControladorTransacao().inserirOperacaoEfetuada( objetoTransacao.getUsuarioAcaoUsuarioHelp(), objetoTransacao.getOperacaoEfetuada(), tabelaLinhaAlteracao, collTabelaLinhaColunaAlteracao); this.salvarTabelaLinhaAlteracaoPrincipal(objetoTransacao.getOperacaoEfetuada(), objetoTransacao); objetoTransacao.setUltimaAlteracao(new Date(System.currentTimeMillis())); } catch (Exception e) { throw new CallbackException("atencao.registrar.operacao", e); } } else { verificarObjetoAlterado(objetoTransacao,arg); } } } /** * Método que intercepta o alterar do hibernate utilizado para registrar a * operacao * * @author Administrador * @date 25/03/2006 * * @param arg0 * @param arg1 * @param arg2 * @param arg3 * @param arg4 * @param arg5 * @return * @throws CallbackException */ public boolean onFlushDirty(Object arg0, Serializable arg1, Object[] arg2, Object[] arg3, String[] arg4, Type[] arg5) throws CallbackException { translate(arg0, arg1, arg2, arg4, arg5); if (arg0 instanceof ObjetoTransacao) { ObjetoTransacao novo = (ObjetoTransacao) arg0; if (novo.getUsuarioAcaoUsuarioHelp() == null || novo.getUsuarioAcaoUsuarioHelp().isEmpty()) { return true;// throw new // CallbackException("atencao.usuario.vazia"); } if (novo.getOperacaoEfetuada() == null) { return true;// throw new // CallbackException("atencao.operacaoEfetuada.vazia"); } if (novo.getOperacaoEfetuada().getOperacao() == null) { return true;// throw new // CallbackException("atencao.operacao.vazia"); } verificarObjetoAlterado(novo,arg4); } return true; } /** * Método que intercepta o delete do hibernte utilizado pra registrar a * operacao * * @author Thiago Toscano * @date 25/03/2006 * * @param arg0 * objeto a ser salvo * @param arg1 * a chame primaria do objeto a ser salvo * @param arg2 * array de todos os valores do objeto * @param arg3 * array dos nomes de as propriedades do objeto * @param arg4 * array dos tipos das propriedades do objeto * @return * @throws CallbackException */ public void onDelete(Object arg0, Serializable arg1, Object[] arg2, String[] arg3, Type[] arg4) throws CallbackException { if (arg0 instanceof ObjetoTransacao) { ObjetoTransacao objetoTransacao = (ObjetoTransacao) arg0; if (objetoTransacao.getUsuarioAcaoUsuarioHelp() == null || objetoTransacao.getUsuarioAcaoUsuarioHelp().isEmpty()) { return; // throw new CallbackException("atencao.usuario.vazia"); } if (objetoTransacao.getOperacaoEfetuada() == null) { return; // throw new // CallbackException("atencao.operacaoEfetuada.vazia"); } if (objetoTransacao.getOperacaoEfetuada().getOperacao() == null) { return; // throw new CallbackException("atencao.operacao.vazia"); } registrarExclusao(arg0); } } public void registrarExclusao(Object obj){ if (obj instanceof ObjetoTransacao){ ObjetoTransacao objetoTransacao = (ObjetoTransacao) obj; // verifica se a classe possui controle de registrar transacao if (!objetoTransacao.temControleAlteracao()){ return; } try { String nomeTabela = HibernateUtil.getNameTable(objetoTransacao.getClass()); FiltroTabela filtroTabela = new FiltroTabela(); filtroTabela.adicionarParametro(new ParametroSimples(FiltroTabela.NOME, nomeTabela)); Collection coll = getControladorUtil().pesquisar(filtroTabela,Tabela.class.getSimpleName()); Tabela tabela = null; if (coll != null && !coll.isEmpty()) { tabela = (Tabela) coll.iterator().next(); } else { return; /* * Foi acordado retirar a inclusão automática de tabelas e colunas não encontradas * Francisco Nascimento, 05/03/08 * tabela = new Tabela(); tabela.setNomeTabela(nomeTabela); tabela.setDescricao(nomeTabela); tabela.setUltimaAlteracao(new Date(System.currentTimeMillis())); this.getControladorUtil().inserir(tabela); */ } objetoTransacao.getOperacaoEfetuada().preencherDadosAdicionais(objetoTransacao); AlteracaoTipo alteracaoTipo = new AlteracaoTipo(); alteracaoTipo.setId(AlteracaoTipo.EXCLUSAO); TabelaLinhaAlteracao tabelaLinhaAlteracao = new TabelaLinhaAlteracao(); tabelaLinhaAlteracao.setUltimaAlteracao(new Date(System.currentTimeMillis())); tabelaLinhaAlteracao.setTabela(tabela); tabelaLinhaAlteracao.setAlteracaoTipo(alteracaoTipo); Collection collTabelaLinhaColunaAlteracao = new ArrayList(); // Adicionando uma linha com a descricao do objeto, caso esta descricao não seja vazia String[] keys = objetoTransacao.retornaCamposChavePrimaria(); for (int i = 0; keys != null && i < keys.length; i++) { String id = keys[i]; //String nomeMetodoKey = "get" // + id.substring(0, 1).toUpperCase() //+ id.substring(1, id.length()); //Method metodoNovo = objetoTransacao.getClass().getMethod(nomeMetodoKey, (Class[])null); //Object retornoKeyNovo = metodoNovo.invoke(objetoTransacao, (Object[])null); String descricaoNovo = consultarDescricao(objetoTransacao); if (!descricaoNovo.equals("")){ TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = gerarTabelaLinhaColunaAlteracao( id, objetoTransacao.getTipoAtributo(id),"", descricaoNovo); if (tabelaLinhaColunaAlteracao != null) tabelaLinhaColunaAlteracao.setTabelaLinhaAlteracao(tabelaLinhaAlteracao); // Pesquisa a Tabelacoluna TabelaColuna tabelaColuna = gerarTabelaColuna(tabela, id, objetoTransacao); tabelaLinhaColunaAlteracao.setTabelaColuna(tabelaColuna); collTabelaLinhaColunaAlteracao.add(tabelaLinhaColunaAlteracao); } break; } collTabelaLinhaColunaAlteracao.addAll( gerarTabelaLinhaColunaAlteracaoInclusaoOuExclusao(false, true, objetoTransacao, tabelaLinhaAlteracao)); // fim: adicionando descricao como alteracao Integer[] ids = getIds(objetoTransacao); if (ids != null && ids.length > 0) { tabelaLinhaAlteracao.setId1(ids[0]); } if (ids != null && ids.length > 1) { tabelaLinhaAlteracao.setId2(ids[1]); } this.getControladorTransacao().inserirOperacaoEfetuada( objetoTransacao.getUsuarioAcaoUsuarioHelp(), objetoTransacao.getOperacaoEfetuada(), tabelaLinhaAlteracao, collTabelaLinhaColunaAlteracao); this.salvarTabelaLinhaAlteracaoPrincipal(objetoTransacao.getOperacaoEfetuada(), objetoTransacao); } catch (Exception e) { throw new CallbackException("atencao.registrar.operacao", e); } } } private Integer[] getIds(ObjetoGcom objetoTransacao) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { Integer[] retorno = null; String[] arg = objetoTransacao.retornaCamposChavePrimaria(); retorno = new Integer[arg.length]; // pegando o primeiro id do objeto passado if (arg != null && arg.length > 0) { String id = arg[0]; String nomeMetodoKey = "get" + id.substring(0, 1).toUpperCase() + id.substring(1, id.length()); Method metodo = objetoTransacao.getClass().getMethod(nomeMetodoKey,(Class[])null); // pega o retonro do primeiro id Object retornoKey = metodo.invoke(objetoTransacao, (Object[])null); // se for interger é pq foi um id if (retornoKey instanceof Integer) { retorno[0] = (Integer) retornoKey; } else { // se nao foi integer eh pq ele tem um id composto e tem outro // objeto como id if (retornoKey instanceof ObjetoGcom) { ObjetoGcom objetoGcom = (ObjetoGcom) retornoKey; // pega os ids do objeto que é id do objeto passado String[] camposChavePrimaria = objetoGcom.retornaCamposChavePrimaria(); if (camposChavePrimaria != null && camposChavePrimaria.length > 0) { String idCamposChavePrimaria = camposChavePrimaria[0]; String nomeCamposChavePrimaria = "get"+ idCamposChavePrimaria.substring(0, 1).toUpperCase() + idCamposChavePrimaria.substring(1,idCamposChavePrimaria.length()); Method metodoCamposChavePrimaria = objetoGcom.getClass().getMethod(nomeCamposChavePrimaria, (Class[])null); // invoca o id do objeto que é id do objeto passado Object retornoKeyCamposChavePrimaria = metodoCamposChavePrimaria.invoke(objetoGcom, (Object[])null); if (retornoKeyCamposChavePrimaria instanceof Integer) { retorno[0] = (Integer) retornoKeyCamposChavePrimaria; } else { retorno[0] = new Integer(0); } } } else { retorno[0] = new Integer(0); } } } // pegando o segundo id if (arg != null && arg.length > 1) { String id = arg[1]; String nomeMetodoKey = "get" + id.substring(0, 1).toUpperCase() + id.substring(1, id.length()); Method metodo = objetoTransacao.getClass().getMethod(nomeMetodoKey, (Class[])null); Object retornoKey = metodo.invoke(objetoTransacao, (Object[])null); if (retornoKey instanceof Integer) { retorno[1] = (Integer) retornoKey; } else { // se nao foi integer eh pq ele tem um id composto e tem outro // objeto como id if (retornoKey instanceof ObjetoGcom) { ObjetoGcom objetoGcom = (ObjetoGcom) retornoKey; // pega os ids do objeto que é id do objeto passado String[] camposChavePrimaria = objetoGcom.retornaCamposChavePrimaria(); if (camposChavePrimaria != null && camposChavePrimaria.length > 0) { String idCamposChavePrimaria = camposChavePrimaria[0]; String nomeCamposChavePrimaria = "get"+ idCamposChavePrimaria.substring(0, 1).toUpperCase()+ idCamposChavePrimaria.substring(1,idCamposChavePrimaria.length()); Method metodoCamposChavePrimaria = objetoGcom.getClass().getMethod(nomeCamposChavePrimaria,(Class[])null); // invoca o id do objeto que é id do objeto passado Object retornoKeyCamposChavePrimaria = metodoCamposChavePrimaria.invoke(objetoGcom, (Object[])null); if (retornoKeyCamposChavePrimaria instanceof Integer) { retorno[1] = (Integer) retornoKeyCamposChavePrimaria; } else { retorno[1] = new Integer(0); } } } else { retorno[1] = new Integer(0); } } } return retorno; } private Collection gerarTabelaLinhaColunaAlteracaoInclusaoOuExclusao( boolean insersao, boolean exclusao, ObjetoTransacao objetoTransacao, TabelaLinhaAlteracao tabelaLinhaAlteracao) throws ControladorException, NoSuchMethodException { Collection retorno = new Vector(); String nomeTabela = HibernateUtil.getNameTable(objetoTransacao.getClass()); FiltroTabela filtroTabela = new FiltroTabela(); filtroTabela.adicionarParametro(new ParametroSimples(FiltroTabela.NOME,nomeTabela)); Collection coll = getControladorUtil().pesquisar(filtroTabela,Tabela.class.getSimpleName()); Tabela tabela = null; if (coll != null && !coll.isEmpty()) { tabela = (Tabela) coll.iterator().next(); } else { return null; /* * Foi acordado retirar a inclusão automática de tabelas e colunas não encontradas * Francisco Nascimento, 05/03/08 * tabela = new Tabela(); tabela.setNomeTabela(nomeTabela); tabela.setDescricao(nomeTabela); tabela.setUltimaAlteracao(new Date(System.currentTimeMillis())); this.getControladorUtil().inserir(tabela); */ } Class classe = objetoTransacao.getClass(); Method[] metodos = classe.getMethods(); Method metodo; String nomeMetodo; String nomeAtributo; String[] atributosRegistro = objetoTransacao.retornarAtributosSelecionadosRegistro(); for (int i = 0; i < metodos.length; i++) { metodo = metodos[i]; nomeMetodo = metodo.getName(); // se for get e nao for getClass e nao for getUltimaAlteracao if (nomeMetodo.startsWith("get") && !nomeMetodo.startsWith("getClass") && !nomeMetodo.startsWith("getUltimaAlteracao")) { nomeAtributo = nomeMetodo.substring(3, nomeMetodo.length()); if (!nomeAtributo.equals("")){ nomeAtributo = nomeAtributo.substring(0, 1).toLowerCase()+ nomeAtributo.substring(1, nomeAtributo.length()); } else { continue; } // verificando se houve selecao de atributos para registro boolean atributoEncontrado = false; if (atributosRegistro != null && nomeAtributo != null && !nomeAtributo.equals("")){ for (int j = 0; j < atributosRegistro.length; j++) { if (nomeAtributo.equalsIgnoreCase(atributosRegistro[j])){ atributoEncontrado = true; break; } } if (!atributoEncontrado){ continue; // by pass this attribute } } try { // invocando o metodo do objeto velho para pegar o retorno Object retornoMetodoVelho = metodo.invoke(objetoTransacao,(Object[])null); // verifica se o retorno eh do tipo conhecido if ((retornoMetodoVelho instanceof ObjetoGcom) || (metodo.getReturnType().isPrimitive()) || (retornoMetodoVelho instanceof Short) || (retornoMetodoVelho instanceof Byte) || (retornoMetodoVelho instanceof Character) || (retornoMetodoVelho instanceof Integer) || (retornoMetodoVelho instanceof Long) || (retornoMetodoVelho instanceof Double) || (retornoMetodoVelho instanceof Float) || (retornoMetodoVelho instanceof String) || (retornoMetodoVelho instanceof Boolean) || (retornoMetodoVelho instanceof BigDecimal) || (retornoMetodoVelho instanceof Date)) { // invocando o metodo do objeto novo para pegar o // retorno Object retornoMetodoNovo = metodo.invoke(objetoTransacao, (Object[])null); TabelaColuna tabelaColuna = gerarTabelaColuna(tabela,nomeAtributo, objetoTransacao); if (retornoMetodoNovo != null && tabelaColuna != null) { Object retornoMetodo = ""; if (retornoMetodoNovo instanceof ObjetoGcom) { ObjetoGcom objetoGcom = (ObjetoGcom) retornoMetodoNovo; Integer[] ids = getIds(objetoGcom); if (ids != null && ids.length > 0) { retornoMetodo = ids[0] + ""; } if (ids != null && ids.length > 1) { retornoMetodo = retornoMetodo + "" + ids[1]; } // pegando a descricao do objeto gcom // Para obtencao da descricao, é necessário se ter um objeto do // tipo ObjetoTransacao, pois será usado um método definido nesta classe // (getDescricaoParaRegistroTransacao) if (objetoGcom instanceof ObjetoTransacao){ retornoMetodo = consultarDescricao((ObjetoTransacao) objetoGcom); // ObjetoTransacao objTransNovo = (ObjetoTransacao) objetoGcom; // ObjetoTransacao objTransVelho = (ObjetoTransacao) retornoMetodoVelho; // if (retornoMetodo == null || retornoMetodo.equals("") || retornoMetodo.equals("null")){ // tabelaLinhaColunaAlteracoes = compareObjetoTransacao( // objTransNovo, objTransVelho , objTransNovo.retornarAtributosSelecionadosRegistro()); // retorno.addAll(tabelaLinhaColunaAlteracoes); // } } } else { retornoMetodo = retornoMetodoNovo; } if (retornoMetodo != null && !retornoMetodo.equals("")){ TabelaLinhaColunaAlteracao tabelaLinhaColunaAlteracao = new TabelaLinhaColunaAlteracao(); tabelaLinhaColunaAlteracao.setTabelaColuna(tabelaColuna); tabelaLinhaColunaAlteracao.setTabelaLinhaAlteracao(tabelaLinhaAlteracao); tabelaLinhaColunaAlteracao.setUltimaAlteracao(new Date(System.currentTimeMillis())); tabelaLinhaColunaAlteracao.setConteudoColunaAtual(" "); tabelaLinhaColunaAlteracao.setConteudoColunaAnterior(" "); if (insersao) { tabelaLinhaColunaAlteracao.setConteudoColunaAtual(retornoMetodo); } if (exclusao) { tabelaLinhaColunaAlteracao.setConteudoColunaAnterior(retornoMetodo); } retorno.add(tabelaLinhaColunaAlteracao); } } } } catch (IllegalArgumentException e) { e.printStackTrace(); // e.printStackTrace(); // nunca entra aqui // excecao levantada quando o metodo invocado nao existe no // objeto passado // o metodo invocado foi pego da lista do objeto que se // deseja utilizar } catch (IllegalAccessException e) { e.printStackTrace(); // e.printStackTrace(); // nunca entra aqui // excecao levantada quando o metodo invocado nao existe no // objeto passado // o metodo invocado foi pego da lista do objeto que se // deseja utilizar } catch (InvocationTargetException e) { e.printStackTrace(); // e.printStackTrace(); // nunca entra aqui // excecao levantada quando o metodo invocado nao existe no // objeto passado // o metodo invocado foi pego da lista do objeto que se // deseja utilizar } catch (SecurityException e) { e.printStackTrace(); } } } return retorno; } /** * Método que gera TabelaLinhaAlteracao a partir do nome do atributo de uma * classe e seu retorno * * @author Administrador * @date 04/04/2006 * * @param nomeAtributo * @param retonro * @return * @throws ControladorException */ private TabelaColuna gerarTabelaColuna(Tabela tabela, String nomeAtributo,ObjetoTransacao objetoTransacao) throws ControladorException { TabelaColuna retorno = null; String nomeColuna = HibernateUtil.getNameColumn(objetoTransacao.getClass(), nomeAtributo); if (nomeColuna != null) { FiltroTabelaColuna filtroTabelaColuna = new FiltroTabelaColuna(); filtroTabelaColuna.adicionarParametro(new ParametroSimples(FiltroTabelaColuna.TABELA_ID, tabela.getId())); filtroTabelaColuna.adicionarParametro(new ParametroSimples(FiltroTabelaColuna.COLUNA, nomeColuna)); Collection coll = this.getControladorUtil().pesquisar(filtroTabelaColuna, TabelaColuna.class.getSimpleName()); if (coll != null && !coll.isEmpty()) { retorno = (TabelaColuna) coll.iterator().next(); } else { return null; /* * Foi acordado retirar a inclusão automática de tabelas e colunas não encontradas * Francisco Nascimento, 05/03/08 * retorno = new TabelaColuna(); retorno.setColuna(nomeColuna); retorno.setDescricaoColuna(nomeColuna); retorno.setTabela(tabela); retorno.setUltimaAlteracao(new Date(System.currentTimeMillis())); Integer idTabelaColuna = (Integer) this.getControladorUtil().inserir(retorno); retorno.setId(idTabelaColuna); // inserindo a ordem de exibicao desta tabela coluna Operacao operacao = objetoTransacao.getOperacaoEfetuada().getOperacao(); OperacaoOrdemExibicao ordemColuna = new OperacaoOrdemExibicao(); ordemColuna.setComp_id(new OperacaoOrdemExibicaoPK(new Integer(operacao.getId()), tabela.getId())); ordemColuna.setTabelaColuna(retorno); this.getControladorUtil().inserir(ordemColuna); */ } } return retorno; } public int[] findDirty(Object arg0, Serializable arg1, Object[] arg2,Object[] arg3, String[] arg4, Type[] arg5) { return null; } public void afterTransactionBegin(Transaction arg0) { // System.out.println("2"); } public void afterTransactionCompletion(Transaction arg0) { // System.out.println("3"); } public void beforeTransactionCompletion(Transaction arg0) { // System.out.println("4"); } public Object getEntity(String arg0, Serializable arg1) throws CallbackException { // System.out.println("5"); return null; } public String getEntityName(Object arg0) throws CallbackException { // System.out.println("6"); return null; } public Object instantiate(String arg0, EntityMode arg1, Serializable arg2)throws CallbackException { // System.out.println("7"); return null; } public Boolean isTransient(Object arg0) { // System.out.println("8"); return new Boolean(false); } public void onCollectionRecreate(Object arg0, Serializable arg1)throws CallbackException { // System.out.println(">>>> onCollectionRecreate"); } public void onCollectionRemove(Object arg0, Serializable arg1)throws CallbackException { // System.out.println(">>>>> onCollectionRemove: " + arg1); } public void onCollectionUpdate(Object arg0, Serializable arg1)throws CallbackException { // System.out.println(">>>>> onCollectionUpdate"); } public boolean onLoad(Object arg0, Serializable arg1, Object[] arg2, String[] arg3, Type[] arg4) throws CallbackException { translate(arg0, arg1, arg2, arg3, arg4); return true; } public String onPrepareStatement(String arg0) { if (arg0.toUpperCase().startsWith("INSERT".toUpperCase())) { arg0 = arg0.toUpperCase().replace("INSERT INTO".toUpperCase(), "INSERT /*+ append */ INTO ".toUpperCase()); } return arg0; } public void postFlush(Iterator arg0) throws CallbackException { // System.out.println("17"); } public void preFlush(Iterator arg0) throws CallbackException { // System.out.println("preFlush"); } /** * Esta função faz o translate dos dados que entram e saem da base O * translate nada mais é do que um replace dos caracteres especiais por * caracteres normais * * @author Rodrigo Silveira * @date 12/07/2006 * * @param arg0 * entidade * @param arg1 * chave primária * @param arg2 * valor das propriedades * @param arg3 * nomes das propriedades * @param arg4 * tipos */ private void translate(Object entidade, Serializable chavePrimaria,Object[] valorPropriedades, String[] nomesPropriedades, Type[] tipos) { for (int i = 0; i < valorPropriedades.length; i++) { Object valorPropriedade = valorPropriedades[i]; if (valorPropriedade instanceof String) { // Pega cada propriedade // para verificar se é // String String valorPropriedadeString = (String) valorPropriedade; if (valorPropriedadeString != null && !valorPropriedadeString.trim().equals("") && !valorPropriedadeString .matches("[\\w&&[^ÃÕÁÉÍÓÚÀÂÊÔÜÇãõáéíóúàãêôüç]]*")) { // Verifica // se // existe // algum // caracter // especial // na // String // Faz o replace para tirar os caracteres especiais da // String valorPropriedades[i] = ((String) valorPropriedade).trim() .replace('Ã', 'A').replace('Õ', 'O').replace('Á', 'A').replace('É', 'E').replace('Í', 'I') .replace('Ú', 'U').replace('À', 'A').replace('Â', 'A').replace('Ê', 'E').replace('Ô', 'O') .replace('Ü', 'U').replace('Ç', 'C').replace('ã', 'A').replace('õ', 'O').replace('á', 'A') .replace('é', 'E').replace('í', 'I').replace('ú', 'U').replace('à', 'A').replace('â', 'A') .replace('ê', 'E').replace('ô', 'O').replace('ü', 'U').replace('ç', 'C'); // ÃÕÁÉÍÓÚÀÂÊÔÜÇ } } } } /** * * * @author Pedro Alexandre * @date 21/08/2006 * * @param colecaoObjetosAtualizados * @param classMetadata * @param alteracoes * @param idOperacao */ public void registrarTransacaoHQL(Collection colecaoObjetosAtualizados, ClassMetadata classMetadata, Map alteracoes, Integer idOperacao){ String[] propriedades = classMetadata.getPropertyNames(); Object[] valorPropriedades = alteracoes.values().toArray(); valorPropriedades = translateRegistrarTransacaoHQL(valorPropriedades); if(colecaoObjetosAtualizados != null){ for(Object objetoAtualizado : colecaoObjetosAtualizados){ if(objetoAtualizado instanceof ObjetoTransacao){ ObjetoTransacao objetoTransacao = (ObjetoTransacao) objetoAtualizado; //------------ REGISTRAR TRANSAÇÃO ---------------- Usuario usuarioLogado = Usuario.USUARIO_TESTE; RegistradorOperacao registradorOperacao = new RegistradorOperacao(idOperacao,new UsuarioAcaoUsuarioHelper(usuarioLogado, UsuarioAcao.USUARIO_ACAO_EFETUOU_OPERACAO)); Operacao operacaoRegistrarTransacao = new Operacao(); operacaoRegistrarTransacao.setId(idOperacao); OperacaoEfetuada operacaoEfetuada = new OperacaoEfetuada(); operacaoEfetuada.setOperacao(operacaoRegistrarTransacao); objetoTransacao.setOperacaoEfetuada(operacaoEfetuada); objetoTransacao.adicionarUsuario(usuarioLogado,UsuarioAcao.USUARIO_ACAO_EFETUOU_OPERACAO); registradorOperacao.registrarOperacao(objetoTransacao); //------------ REGISTRAR TRANSAÇÃO ---------------- //------------- ATUALIZAR DADOS DO OBJETO ALTERADO --------------- if(propriedades != null && propriedades.length > 0){ for (int i = 0; i < propriedades.length; i++) { if(alteracoes.containsKey(propriedades[i])){ Class classe = objetoTransacao.getClass(); String nomeAtributo = propriedades[i]; String nomeMetodo; nomeMetodo = "set" + nomeAtributo.substring(0, 1).toUpperCase()+ nomeAtributo.substring(1, nomeAtributo.length()); Method metodo; try { /*metodo = classe.getMethod(nomeMetodo, (Class[]) null); Object[] args = {alteracoes.get(propriedades[i])}; metodo.invoke(objetoTransacao,args); */ Method[] metodos = classe.getMethods(); if(metodos != null && metodos.length > 0){ for (int j = 0; j < metodos.length; j++) { metodo = metodos[j]; if(metodo.getName().equals(nomeMetodo)){ Object[] args = {alteracoes.get(propriedades[i])}; metodo.invoke(objetoTransacao,args); break; } } } } catch (SecurityException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } } } } //------------- FIM ATUALIZAR DADOS DO OBJETO ALTERADO --------------- verificarObjetoAlterado(objetoTransacao,propriedades); } } } } /** * * * @author Pedro Alexandre * @date 21/08/2006 * * @param valorPropriedades * @return */ private Object[] translateRegistrarTransacaoHQL(Object[] valorPropriedades) { for (int i = 0; i < valorPropriedades.length; i++) { Object valorPropriedade = valorPropriedades[i]; if (valorPropriedade instanceof String) { // Pega cada propriedade String valorPropriedadeString = (String) valorPropriedade; if (valorPropriedadeString != null && !valorPropriedadeString.trim().equals("") && !valorPropriedadeString.matches("[\\w&&[^ÃÕÁÉÍÓÚÀÂÊÔÜÇãõáéíóúàãêôüç]]*")) { valorPropriedades[i] = ((String) valorPropriedade).trim() .replace('Ã', 'A').replace('Õ', 'O').replace('Á', 'A').replace('É', 'E').replace('Í', 'I') .replace('Ú', 'U').replace('À', 'A').replace('Â', 'A').replace('Ê', 'E').replace('Ô', 'O') .replace('Ü', 'U').replace('Ç', 'C').replace('ã', 'A').replace('õ', 'O').replace('á', 'A') .replace('é', 'E').replace('í', 'I').replace('ú', 'U').replace('à', 'A').replace('â', 'A') .replace('ê', 'E').replace('ô', 'O').replace('ü', 'U').replace('ç', 'C'); // ÃÕÁÉÍÓÚÀÂÊÔÜÇ } } } return valorPropriedades; } /** * Consultar a descrição de um objeto Gcom, caso a descrição esteja nula, realizará * uma busca no banco pra obter a descrição * @param gcom * @return */ public static String consultarDescricao(Object obj){ String descricao = ""; ObjetoTransacao objTrans = null; if (obj instanceof ObjetoTransacao){ objTrans = (ObjetoTransacao) obj; } else { return ""; } try { try { descricao = objTrans.getDescricaoParaRegistroTransacao(); } catch (LazyInitializationException lie){ objTrans = consultarObjetoCarregandoAtributo(objTrans); descricao = objTrans.getDescricaoParaRegistroTransacao(); return ""; } // a descricao está nula, então vamos consultar no banco o objeto para obter a descricao // isto acontece nas situacoes que foi instanciado um objeto apenas com seu identificador if (descricao == null){ // consultar no banco a descrição if (objTrans instanceof ObjetoTransacao){ try { Filtro filtro = objTrans.retornaFiltroRegistroOperacao(); Collection coll = RepositorioUtilHBM.getInstancia().pesquisar(filtro, objTrans.getClass().getName()); Object objConsultado = Util.retonarObjetoDeColecao(coll); if (objConsultado != null){ ObjetoTransacao objTransacao = (ObjetoTransacao) objConsultado; descricao = objTransacao.getDescricaoParaRegistroTransacao(); // metodoDescricao = objTransacao.getClass().getMethod(nomeMetodoDescricao, (Class[])null); // descricao = (String) metodoDescricao.invoke(objTransacao, (Object[])null); } } catch (ErroRepositorioException e) { e.printStackTrace(); } catch(Exception e){ } } } } catch (SecurityException e) { e.printStackTrace(); } catch (IllegalArgumentException e) { e.printStackTrace(); } return descricao; } /** * Salvar tabela linha alteracao principal, que é único para cada operacao. * @param operacaoEfetuada * @param objetoTransacao */ private void salvarTabelaLinhaAlteracaoPrincipal(OperacaoEfetuada operacaoEfetuada, ObjetoTransacao objetoTransacao){ if (operacaoEfetuada != null && operacaoEfetuada.getId() != null && operacaoEfetuada.getTabelaLinhaAlteracaoPrincipal() == null){ TabelaLinhaAlteracao tabelaLinhaAlteracao = new TabelaLinhaAlteracao(); tabelaLinhaAlteracao.setUltimaAlteracao(new Date(System.currentTimeMillis())); String nomeTabela = HibernateUtil.getNameTable(objetoTransacao.getClass()); FiltroTabela filtroTabela = new FiltroTabela(); filtroTabela.adicionarParametro(new ParametroSimples(FiltroTabela.NOME,nomeTabela)); Collection coll = null; try { coll = getControladorUtil().pesquisar(filtroTabela,Tabela.class.getSimpleName()); } catch (ControladorException e) { e.printStackTrace(); } Tabela tabela = null; if (coll != null && !coll.isEmpty()) { tabela = (Tabela) coll.iterator().next(); } AlteracaoTipo alteracaoTipo = new AlteracaoTipo(); alteracaoTipo.setId(AlteracaoTipo.INCLUSAO); tabelaLinhaAlteracao.setTabela(tabela); tabelaLinhaAlteracao.setAlteracaoTipo(alteracaoTipo); tabelaLinhaAlteracao.setOperacaoEfetuada(operacaoEfetuada); tabelaLinhaAlteracao.setIndicadorPrincipal(TabelaLinhaAlteracao.INDICADOR_TABELA_LINHA_ALTERACAO_PRINCIPAL); tabelaLinhaAlteracao.setId1(operacaoEfetuada.getIdObjetoPrincipal()); tabelaLinhaAlteracao.setId2(objetoTransacao.getId2()); try { this.getControladorUtil().inserir(tabelaLinhaAlteracao); operacaoEfetuada.setTabelaLinhaAlteracaoPrincipal(tabelaLinhaAlteracao); } catch (ControladorException e) { e.printStackTrace(); } } } }