From 1aa1daed76de4fcc287da4d5dc938ae85277121c Mon Sep 17 00:00:00 2001 From: wilian Date: Sat, 21 Nov 2020 18:37:42 +0000 Subject: [PATCH] bug#20778 dev:wilian qua: git-svn-id: http://desenvolvimento.rjconsultores.com.br/repositorio/sco/Outros/Auditador/trunk@104398 d1611594-4594-4d17-8e1d-87c2c4800839 --- .../auditador/annotations/AuditarClasse.java | 14 +- .../annotations/AuditarEntidade.java | 3 - .../auditador/annotations/AuditarID.java | 6 +- .../annotations/AuditarIDComposta.java | 15 + .../auditador/annotations/AuditarLista.java | 3 - .../auditador/annotations/AuditarMetodo.java | 28 ++ .../auditador/annotations/NaoAuditar.java | 3 - .../auditador/auditadores/Auditador.java | 386 ++++++++++++++---- .../auditadores/AuditadorAtributo.java | 10 +- .../auditadores/AuditadorEntidade.java | 48 ++- .../auditador/auditadores/AuditadorList.java | 59 +-- .../auditadores/ExtrairAnotacao.java | 18 + .../auditador/enums/TipoExtracaoDados.java | 8 + .../auditador/model/AuditadorObjects.java | 11 +- 14 files changed, 448 insertions(+), 164 deletions(-) create mode 100644 src/main/java/br/com/rjconsultores/auditador/annotations/AuditarIDComposta.java create mode 100644 src/main/java/br/com/rjconsultores/auditador/annotations/AuditarMetodo.java create mode 100644 src/main/java/br/com/rjconsultores/auditador/enums/TipoExtracaoDados.java diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarClasse.java b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarClasse.java index 22ae6320c..2611fac44 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarClasse.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarClasse.java @@ -5,6 +5,8 @@ import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; +import br.com.rjconsultores.auditador.enums.TipoExtracaoDados; + /** * Anotação responsável por indicar que a classe será auditada. * @@ -20,14 +22,14 @@ public @interface AuditarClasse { */ String nome(); - /** - * Quando a classe possuir o campo que indica a empresa. - */ - String campoEmpresa() default ""; - /** * Atributo para indicar qual tela que o objeto será auditado. */ String tela(); - + + /** + * Define se as informações serão extraídas pelo atributo ou metodo. + * @return + */ + TipoExtracaoDados tipoExtracaoDados() default TipoExtracaoDados.ATRIBUTO; } diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarEntidade.java b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarEntidade.java index 48c698a02..ae2370025 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarEntidade.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarEntidade.java @@ -1,9 +1,7 @@ package br.com.rjconsultores.auditador.annotations; -import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; /** * Anotação responsável que indicará que o atributo é uma entidade e seus atributos deverão ser auditados individualmente. @@ -11,7 +9,6 @@ import java.lang.annotation.Target; * @author wilian * */ -@Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface AuditarEntidade { diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarID.java b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarID.java index 2e3c4e86c..6ab8916f9 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarID.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarID.java @@ -1,9 +1,7 @@ package br.com.rjconsultores.auditador.annotations; -import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; /** * Anotação responsável para indicar qual o atributo que representa a chave primária da classe. @@ -11,8 +9,10 @@ import java.lang.annotation.Target; * @author wilian * */ -@Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface AuditarID { + + String nome() default ""; + String pattern() default ""; } diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarIDComposta.java b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarIDComposta.java new file mode 100644 index 000000000..143666170 --- /dev/null +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarIDComposta.java @@ -0,0 +1,15 @@ +package br.com.rjconsultores.auditador.annotations; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** + * Anotação responsável para indicar qual o atributo que representa a chave primária composta da classe. + * + * @author wilian + * + */ +@Retention(RetentionPolicy.RUNTIME) +public @interface AuditarIDComposta { + +} diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarLista.java b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarLista.java index 88c9a95e9..0e852110e 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarLista.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarLista.java @@ -1,9 +1,7 @@ package br.com.rjconsultores.auditador.annotations; -import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; /** * Anotação responsável para auditar o campos que são listas. @@ -11,7 +9,6 @@ import java.lang.annotation.Target; * @author wilian * */ -@Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface AuditarLista { diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarMetodo.java b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarMetodo.java new file mode 100644 index 000000000..2a472fd5f --- /dev/null +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarMetodo.java @@ -0,0 +1,28 @@ +package br.com.rjconsultores.auditador.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Anotação utilizada para methodos. + * + * @author wilian + * + */ +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface AuditarMetodo { + + /** + * Caso seja necessário colocar um nome amigável para o atributo, senão for informado o padrão será o nome do atributo da classe. + */ + String nome() default ""; + + /** + * Em caso de um atributo do tipo "DATE", informar o formato da data, valor padrão: "dd/MM/yyyy HH:mm" + */ + String pattern() default "dd/MM/yyyy HH:mm"; + +} diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/NaoAuditar.java b/src/main/java/br/com/rjconsultores/auditador/annotations/NaoAuditar.java index cd5868cb4..bc8d73c4f 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/NaoAuditar.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/NaoAuditar.java @@ -1,9 +1,7 @@ package br.com.rjconsultores.auditador.annotations; -import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; /** * Anotação responsável para indicar que o atributo não deverá ser auditado, por padrão todos os atributos da classe são auditados. @@ -11,7 +9,6 @@ import java.lang.annotation.Target; * @author wilian * */ -@Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface NaoAuditar { diff --git a/src/main/java/br/com/rjconsultores/auditador/auditadores/Auditador.java b/src/main/java/br/com/rjconsultores/auditador/auditadores/Auditador.java index e2bc75455..3219b0531 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/Auditador.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/Auditador.java @@ -1,6 +1,9 @@ package br.com.rjconsultores.auditador.auditadores; +import java.lang.reflect.AccessibleObject; import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; import java.math.BigDecimal; import java.text.NumberFormat; import java.text.ParseException; @@ -17,9 +20,12 @@ import br.com.rjconsultores.auditador.annotations.AuditarAtributo; import br.com.rjconsultores.auditador.annotations.AuditarClasse; import br.com.rjconsultores.auditador.annotations.AuditarEntidade; import br.com.rjconsultores.auditador.annotations.AuditarID; +import br.com.rjconsultores.auditador.annotations.AuditarIDComposta; import br.com.rjconsultores.auditador.annotations.AuditarLista; +import br.com.rjconsultores.auditador.annotations.AuditarMetodo; import br.com.rjconsultores.auditador.annotations.NaoAuditar; import br.com.rjconsultores.auditador.enums.AuditadorTipoAlteracao; +import br.com.rjconsultores.auditador.enums.TipoExtracaoDados; import br.com.rjconsultores.auditador.exceptions.AuditadorException; import br.com.rjconsultores.auditador.interfaces.Auditavel; import br.com.rjconsultores.auditador.interfaces.AuditavelTelaAlternativa; @@ -39,6 +45,7 @@ public class Auditador { ExtrairAnotacao extrairAnotacao; private AuditadorObjects padrao; + private TipoExtracaoDados tipoExtracaoDados; private Auditador() { super(); @@ -58,13 +65,14 @@ public class Auditador { * * @param original * @param novo + * @param empresaId * @return */ public List auditar(Object original, Object novo) { List lsRetorno = new ArrayList(); try { - if(isObjetosNulos(original, novo) || !iniciarObjetoPadrao(novo != null ? novo : original, original == null)) { + if(isObjetosNulos(original, novo) || !iniciarObjetoPadrao(novo != null ? novo : original, original == null ? AuditadorTipoAlteracao.INCLUSAO : AuditadorTipoAlteracao.ALTERACAO)) { return lsRetorno; } @@ -83,6 +91,37 @@ public class Auditador { } } + /** + * Responsável por auditar os registros filhos do objeto de referencia. + * + * @param objetoReferencia + * @param original + * @param novo + * @return + */ + public List auditar(Object objetoReferencia, Object original, Object novo) { + List lsRetorno = new ArrayList(); + try { + + if(!iniciarObjetoPadrao(objetoReferencia, AuditadorTipoAlteracao.ALTERACAO)) { + return lsRetorno; + } + + AuditadorObjects objectNovo = auditarObjetoNovo(null, original, novo); + if(objectNovo != null) { + lsRetorno.add(objectNovo); + return lsRetorno; + } + + lsRetorno.addAll(auditarCampos(original, novo, original != null ? original.getClass().getSimpleName() : novo.getClass().getSimpleName())); + return lsRetorno; + } catch (Exception e) { + throw new AuditadorException(e.getMessage(), e); + } catch (Throwable e) { + throw new AuditadorException(e.getMessage(), e); + } + } + /** * Responsável por auditar a lista quando a alteração acontece exclusivamente nos atributos lista do objeto * @@ -92,28 +131,43 @@ public class Auditador { * @param novo * @return */ - public List auditarList(Object objeto, String nomeCampoListAuditar, List original, List novo) { + public List auditarList(Object objeto, String nomeCampoListAuditar, List original, List novo) { List lsRetorno = new ArrayList(); try { - if(!isObjetosNulos(original, novo)) { - Class classe = original != null ? original.getClass() : novo.getClass(); - Field[] campos = classe.getDeclaredFields(); - for (Field campo : campos) { - campo.setAccessible(true); - if(!campo.getName().equals(nomeCampoListAuditar)) { - continue; - } - - NaoAuditar naoAuditar = extrairAnotacao.extrairNaoAuditar(campo); - if(naoAuditar != null) { - continue; - } - - AuditarLista auditarLista = extrairAnotacao.extrairAuditarLista(campo); - lsRetorno.addAll(auditadorList.auditar(campo, original, novo, auditarLista.auditarEntidades())); - - break; + if(!iniciarObjetoPadrao(objeto, AuditadorTipoAlteracao.ALTERACAO) || isObjetosNulos(original, novo)) { + return lsRetorno; + } + + Class classe = objeto.getClass(); + + List camposAuditaveis = extrairCamposAuditaveis(classe); + for (AccessibleObject campo : camposAuditaveis) { + campo.setAccessible(true); + String nome = extrairDeclaredNomeCampo(campo); + + if(!nome.equals(nomeCampoListAuditar)) { + continue; } + + NaoAuditar naoAuditar = extrairAnotacao.extrairNaoAuditar(campo); + if(naoAuditar != null) { + continue; + } + + List lsOriginal = new ArrayList(); + if(original != null) { + lsOriginal.addAll(original); + } + + List lsNovo = new ArrayList(); + if(novo != null) { + lsNovo.addAll(novo); + } + + AuditarLista auditarLista = extrairAnotacao.extrairAuditarLista(campo); + lsRetorno.addAll(auditadorList.auditarList(campo, auditarLista != null ? auditarLista.auditarEntidades() : false, lsOriginal, lsNovo)); + + break; } } catch (Exception e) { throw new AuditadorException(e.getMessage(), e); @@ -127,13 +181,14 @@ public class Auditador { * Responsável por auditar quando o objeto é excluído. * * @param objeto + * @param empresaId * @return */ public List auditarExclusao(Object objeto) { try { List lsRetorno = new ArrayList(); - if(isObjetosNulos(null, objeto) || !iniciarObjetoPadrao(objeto != null ? objeto : null, false)) { + if(isObjetosNulos(null, objeto) || !iniciarObjetoPadrao(objeto != null ? objeto : null, AuditadorTipoAlteracao.EXCLUSAO)) { return lsRetorno; } @@ -150,7 +205,36 @@ public class Auditador { } } - protected AuditadorObjects auditarObjetoNovo(Field campo, Object original, Object novo) throws CloneNotSupportedException { + /** + * Responsável por auditar quando o objeto sofre uma alteração personalizada. + * + * @param objeto + * @param valorNovo + * @param empresaId + * @return + */ + public List auditarPersonalizado(Object objeto, String valorNovo) { + try { + List lsRetorno = new ArrayList(); + + if(isObjetosNulos(null, objeto) || !iniciarObjetoPadrao(objeto != null ? objeto : null, AuditadorTipoAlteracao.ALTERACAO)) { + return lsRetorno; + } + + AuditadorObjects objetoAuditado = auditarObjetoPersonalizado(objeto, AuditadorTipoAlteracao.ALTERACAO, valorNovo); + if(objetoAuditado != null) { + lsRetorno.add(objetoAuditado); + } + + return lsRetorno; + } catch (Exception e) { + throw new AuditadorException(e.getMessage(), e); + } catch (Throwable e) { + throw new AuditadorException(e.getMessage(), e); + } + } + + protected AuditadorObjects auditarObjetoNovo(AccessibleObject campo, Object original, Object novo) throws CloneNotSupportedException { if(original == null && novo != null) { AuditadorObjects auditado = padrao.clonar(); auditado.setValorNovo(String.format("Registro Criado [%s]", extrairTextoInclusaoExclusao(novo))); @@ -160,17 +244,21 @@ public class Auditador { return null; } - protected AuditadorObjects auditarObjetoExcluido(Object objeto) throws CloneNotSupportedException { + protected AuditadorObjects auditarObjetoPersonalizado(Object objeto, AuditadorTipoAlteracao tipoAlteracao, String valorNovo) throws CloneNotSupportedException { if(objeto != null) { AuditadorObjects auditado = padrao.clonar(); - auditado.setTipoAlteracao(AuditadorTipoAlteracao.EXCLUSAO); - auditado.setValorNovo(String.format("Registro excluido [%s]", extrairTextoInclusaoExclusao(objeto))); + auditado.setTipoAlteracao(tipoAlteracao != null ? tipoAlteracao : AuditadorTipoAlteracao.ALTERACAO); + auditado.setValorNovo(String.format("%s [%s]", valorNovo, extrairTextoInclusaoExclusao(objeto))); return auditado; } return null; } - protected AuditadorObjects auditarCampo(Field campo, Object valorOriginal, Object valorNovo, String nomeClasse) throws CloneNotSupportedException { + protected AuditadorObjects auditarObjetoExcluido(Object objeto) throws CloneNotSupportedException { + return auditarObjetoPersonalizado(objeto, AuditadorTipoAlteracao.EXCLUSAO, "Registro excluido"); + } + + protected AuditadorObjects auditarCampo(AccessibleObject campo, Object valorOriginal, Object valorNovo, String nomeClasse) throws CloneNotSupportedException { if(isDiferente(valorOriginal, valorNovo)) { String nomeCampo = extrairNomeCampo(campo); AuditadorObjects auditado = padrao.clonar(); @@ -194,23 +282,46 @@ public class Auditador { return null; } - protected String extrairNomeCampo(Field campo) { - String nomeCampo = campo != null ? campo.getName() : null; - AuditarAtributo auditarAtributo = extrairAnotacao.extrairAuditarAtributo(campo); - if(auditarAtributo != null && StringUtils.isNotBlank(auditarAtributo.nome())) { - nomeCampo = auditarAtributo.nome(); - } - AuditarEntidade auditarEntidade = extrairAnotacao.extrairAuditarEntidade(campo); - if(auditarEntidade != null && StringUtils.isNotBlank(auditarEntidade.nome())) { - nomeCampo = auditarEntidade.nome(); - } - AuditarLista auditarLista = extrairAnotacao.extrairAuditarLista(campo); - if(auditarLista != null && StringUtils.isNotBlank(auditarLista.nome())) { - nomeCampo = auditarLista.nome(); + protected String extrairNomeCampo(AccessibleObject campo) { + String nomeCampo = null; + if(campo != null) { + AuditarID auditarID = extrairAnotacao.extrairAuditarID(campo); + if(auditarID != null && StringUtils.isNotBlank(auditarID.nome())) { + nomeCampo = auditarID.nome(); + } + AuditarAtributo auditarAtributo = extrairAnotacao.extrairAuditarAtributo(campo); + if(auditarAtributo != null && StringUtils.isNotBlank(auditarAtributo.nome())) { + nomeCampo = auditarAtributo.nome(); + } + AuditarEntidade auditarEntidade = extrairAnotacao.extrairAuditarEntidade(campo); + if(auditarEntidade != null && StringUtils.isNotBlank(auditarEntidade.nome())) { + nomeCampo = auditarEntidade.nome(); + } + AuditarLista auditarLista = extrairAnotacao.extrairAuditarLista(campo); + if(auditarLista != null && StringUtils.isNotBlank(auditarLista.nome())) { + nomeCampo = auditarLista.nome(); + } + AuditarMetodo auditarMetodo = extrairAnotacao.extrairAuditarMetodo(campo); + if(auditarMetodo != null && StringUtils.isNotBlank(auditarMetodo.nome())) { + nomeCampo = auditarMetodo.nome(); + } + + if(StringUtils.isBlank(nomeCampo)) { + nomeCampo = extrairDeclaredNomeCampo(campo); + } } return nomeCampo; } + protected String extrairDeclaredNomeCampo(AccessibleObject campo) { + if(isExtrairDadosAtributo()) { + return ((Field) campo).getName(); + } if(isExtrairDadosMetodo()) { + return ((Method) campo).getName(); + } + return null; + } + protected boolean isDiferente(Object valorOriginal, Object valorNovo) { if(valorOriginal == null && valorNovo == null) { return false; @@ -231,15 +342,8 @@ public class Auditador { List lsRetorno = new ArrayList(); if(!isObjetosNulos(original, novo)) { Class classe = original != null ? original.getClass() : novo.getClass(); - Field[] campos = classe.getDeclaredFields(); - for (Field campo : campos) { - campo.setAccessible(true); - - NaoAuditar naoAuditar = extrairAnotacao.extrairNaoAuditar(campo); - if(naoAuditar != null) { - continue; - } - + List camposAuditaveis = extrairCamposAuditaveis(classe); + for (AccessibleObject campo : camposAuditaveis) { AuditarEntidade auditarEntidade = extrairAnotacao.extrairAuditarEntidade(campo); AuditarLista auditarLista = extrairAnotacao.extrairAuditarLista(campo); @@ -256,15 +360,68 @@ public class Auditador { } - protected Object getValor(Field field, Object object) throws IllegalArgumentException, IllegalAccessException, ParseException { - return getValor(field, object, null); + protected List extrairCamposAuditaveis(Class classe) { + List campo = new ArrayList(); + if(isExtrairDadosAtributo()) { + campo = extrairFields(classe); + } else if(isExtrairDadosMetodo()) { + campo = extrairMethods(classe); + } + return campo; + } + + protected List extrairMethods(Class classe) { + List campos = new ArrayList(); + Method[] methods = classe.getDeclaredMethods(); + for (Method method : methods) { + method.setAccessible(true); + + NaoAuditar naoAuditar = extrairAnotacao.extrairNaoAuditar(method); + if(naoAuditar != null) { + continue; + } + + if(!method.getReturnType().equals(Void.TYPE) && method.getParameterTypes().length == 0 && + !isMethodIgnorado(method)) { + campos.add(method); + } + } + return campos; + } + + private boolean isMethodIgnorado(Method method) { + return method.getName().equalsIgnoreCase("clone") || + method.getName().equalsIgnoreCase("clonar") || + method.getName().equalsIgnoreCase("getCloneObject") || + method.getName().equalsIgnoreCase("hashCode") || + method.getName().equalsIgnoreCase("equals"); + } + + protected List extrairFields(Class classe) { + List campos = new ArrayList(); + Field[] fields = classe.getDeclaredFields(); + for (Field field : fields) { + field.setAccessible(true); + + NaoAuditar naoAuditar = extrairAnotacao.extrairNaoAuditar(field); + if(naoAuditar != null) { + continue; + } + + campos.add(field); + } + return campos; + } + + protected Object getValor(AccessibleObject campo, Object object) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException { + return getValor(campo, object, null); } - protected Object getValor(Field field, Object object, String pattern) throws IllegalArgumentException, IllegalAccessException, ParseException { - if(field == null || object == null) { + protected Object getValor(AccessibleObject campo, Object object, String pattern) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException { + if(campo == null || object == null) { return null; } - Object retorno = field.get(object); + Object retorno = extrairValor(campo, object); Object atributo = null; if (retorno instanceof Date) { @@ -309,11 +466,11 @@ public class Auditador { } @SuppressWarnings("unchecked") - protected List getValorList(Field field, Object object) throws IllegalArgumentException, IllegalAccessException { - if(field == null || object == null) { + protected List getValorList(AccessibleObject campo, Object object) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException { + if(campo == null || object == null) { return new ArrayList(); } - Object aux = field.get(object); + Object aux = extrairValor(campo, object); List retorno = new ArrayList(); if(aux != null && aux instanceof Collection) { @@ -331,17 +488,18 @@ public class Auditador { return novo != null && original == null; } - protected boolean iniciarObjetoPadrao(Object objeto, boolean isObjetoNovo) throws IllegalArgumentException, IllegalAccessException, SecurityException, NoSuchFieldException { + protected boolean iniciarObjetoPadrao(Object objeto, AuditadorTipoAlteracao tipoAlteracao) throws IllegalArgumentException, IllegalAccessException, SecurityException, NoSuchFieldException, ParseException, NoSuchMethodException, InvocationTargetException { padrao = null; Class classe = objeto.getClass(); AuditarClasse auditarClasse = extrairAnotacao.extrair(classe); if(auditarClasse != null) { + tipoExtracaoDados = auditarClasse.tipoExtracaoDados(); padrao = new AuditadorObjects(); - padrao.setTipoAlteracao(isObjetoNovo ? AuditadorTipoAlteracao.INCLUSAO : AuditadorTipoAlteracao.EXCLUSAO); + padrao.setTipoAlteracao(tipoAlteracao); padrao.setTela(getNomeTela(auditarClasse, objeto)); - padrao.setEmpresaId(getEmpresaId(objeto, auditarClasse.campoEmpresa())); padrao.setIdAuditado(getIdEntidade(objeto)); padrao.setClassePrincipal(StringUtils.isNotBlank(auditarClasse.nome()) ? auditarClasse.nome() : classe.getSimpleName()); + } return padrao != null; } @@ -356,41 +514,51 @@ public class Auditador { return auditarClasse.tela(); } - protected Integer getEmpresaId(Object objeto, String campoEmpresa) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException { - if(StringUtils.isBlank(campoEmpresa)) { - return null; - } - + protected String getIdEntidade(Object objeto) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException { + Object valor = null; Class classe = objeto.getClass(); - Field field = classe.getDeclaredField(campoEmpresa); - if(field != null) { - field.setAccessible(true); - Object valor = field.get(objeto); - if(valor instanceof Number) { - return Integer.valueOf(valor.toString()); + List camposAuditaveis = extrairCamposAuditaveis(classe); + for (AccessibleObject campo : camposAuditaveis) { + campo.setAccessible(true); + AuditarID auditarID = extrairAnotacao.extrairAuditarID(campo); + if(auditarID != null) { + valor = getValor(campo, objeto, auditarID.pattern()); } - String idEntidade = getIdEntidade(valor); - if(StringUtils.isNotBlank(idEntidade)) { - return Integer.valueOf(idEntidade); + + if(valor == null) { + AuditarIDComposta auditarIDComposta = extrairAnotacao.extrairAuditarIDComposta(campo); + if(auditarIDComposta != null) { + valor = getIdEntidadeComposta(campo, objeto); + } } + } - return null; + return valor != null ? valor.toString() : null; } - protected String getIdEntidade(Object objeto) throws IllegalArgumentException, IllegalAccessException { - Class classe = objeto.getClass(); - Field[] campos = classe.getDeclaredFields(); - for (Field field : campos) { - field.setAccessible(true); - AuditarID auditarID = extrairAnotacao.extrairAuditarID(field); - if(auditarID != null) { - Object valor = field.get(objeto); - if(valor instanceof Number) { - return valor.toString(); + protected Object getIdEntidadeComposta(AccessibleObject campo, Object objeto) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException { + StringBuilder sb = new StringBuilder(); + if(campo != null && objeto != null) { + Object valorID = extrairValor(campo, objeto); + if(valorID != null) { + Class classe = valorID.getClass(); + List camposAuditaveis = extrairCamposAuditaveis(classe); + for (AccessibleObject campoId : camposAuditaveis) { + campoId.setAccessible(true); + AuditarID auditarID = extrairAnotacao.extrairAuditarID(campoId); + if(auditarID != null) { + Object valor = getValor(campoId, valorID, auditarID.pattern()); + if(valor != null) { + if(sb.length() > 0) { + sb.append("-"); + } + sb.append(valor.toString()); + } + } } } } - return null; + return sb.length() > 0 ? sb.toString() : null; } protected AuditadorObjects getPadrao() { @@ -408,5 +576,53 @@ public class Auditador { } return ""; } + + protected Object extrairValor(AccessibleObject campo, Object object) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException { + if(isExtrairDadosAtributo()) { + return ((Field) campo).get(object); + } else if(isExtrairDadosMetodo()) { + return ((Method) campo).invoke(object); + } + return null; + } + + protected boolean isExtrairDadosAtributo() { + return TipoExtracaoDados.ATRIBUTO.equals(tipoExtracaoDados); + } + + protected boolean isExtrairDadosMetodo() { + return TipoExtracaoDados.METODO.equals(tipoExtracaoDados); + } + + protected String extrairPattern(AccessibleObject campoEntidade) { + String pattern = null; + if(isExtrairDadosAtributo()) { + AuditarAtributo auditarAtributo = extrairAnotacao.extrairAuditarAtributo(campoEntidade); + if(auditarAtributo != null) { + pattern = auditarAtributo.pattern(); + } + } else if(isExtrairDadosMetodo()) { + AuditarMetodo auditarMetodo = extrairAnotacao.extrairAuditarMetodo(campoEntidade); + if(auditarMetodo != null) { + pattern = auditarMetodo.pattern(); + } + } + return pattern; + } + + protected AccessibleObject extrairAccessibleObject(Object objeto, String nome) throws SecurityException, NoSuchFieldException, NoSuchMethodException { + if(objeto != null && StringUtils.isNotBlank(nome)) { + Class classe = objeto.getClass(); + if(isExtrairDadosAtributo()) { + Field field = classe.getDeclaredField(nome); + return field; + } else if(isExtrairDadosMetodo()) { + Method method = classe.getDeclaredMethod(nome); + return method; + } + + } + return null; + } } diff --git a/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorAtributo.java b/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorAtributo.java index b991e3428..a81cc05c0 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorAtributo.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorAtributo.java @@ -1,12 +1,9 @@ package br.com.rjconsultores.auditador.auditadores; -import java.lang.reflect.Field; +import java.lang.reflect.AccessibleObject; import java.util.ArrayList; import java.util.List; -import org.apache.commons.lang.StringUtils; - -import br.com.rjconsultores.auditador.annotations.AuditarAtributo; import br.com.rjconsultores.auditador.exceptions.AuditadorException; import br.com.rjconsultores.auditador.model.AuditadorObjects; @@ -19,13 +16,12 @@ class AuditadorAtributo { this.auditador = auditar; } - public List auditar(Field campo, Object original, Object novo, String nomeClasse) { + public List auditar(AccessibleObject campo, Object original, Object novo, String nomeClasse) { List lsRetorno = new ArrayList(); try { if(!auditador.isObjetosNulos(original, novo)) { - AuditarAtributo auditarAtributo = auditador.extrairAnotacao.extrairAuditarAtributo(campo); - String pattern = auditarAtributo != null && StringUtils.isNotBlank(auditarAtributo.pattern()) ? auditarAtributo.pattern() : null; + String pattern = auditador.extrairPattern(campo); Object valorOriginal = auditador.getValor(campo, original, pattern); Object valorNovo = auditador.getValor(campo, novo, pattern); diff --git a/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorEntidade.java b/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorEntidade.java index d6b6d75eb..45bf41cec 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorEntidade.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorEntidade.java @@ -1,13 +1,9 @@ package br.com.rjconsultores.auditador.auditadores; -import java.lang.reflect.Field; +import java.lang.reflect.AccessibleObject; import java.util.ArrayList; import java.util.List; -import org.apache.commons.lang.StringUtils; - -import br.com.rjconsultores.auditador.annotations.AuditarAtributo; -import br.com.rjconsultores.auditador.annotations.NaoAuditar; import br.com.rjconsultores.auditador.exceptions.AuditadorException; import br.com.rjconsultores.auditador.model.AuditadorObjects; @@ -20,11 +16,11 @@ class AuditadorEntidade { this.auditador = auditar; } - public List auditar(Field campo, Object original, Object novo, String nomeClasse) { + public List auditar(AccessibleObject campo, Object original, Object novo, String nomeClasse) { List lsRetorno = new ArrayList(); try { - Object valorOriginal = campo != null && original != null ? campo.get(original) : original; - Object valorNovo = campo != null && novo != null ? campo.get(novo) : novo; + Object valorOriginal = campo != null && original != null ? auditador.extrairValor(campo, original) : original; + Object valorNovo = campo != null && novo != null ? auditador.extrairValor(campo, novo) : novo; String localNomeClasse = nomeClasse != null ? nomeClasse : auditador.extrairNomeClasse(valorOriginal, valorNovo); @@ -36,17 +32,9 @@ class AuditadorEntidade { if(!auditador.isObjetosNulos(valorOriginal, valorNovo)) { Class classe = valorOriginal != null ? valorOriginal.getClass() : valorNovo.getClass(); - Field[] campos = classe.getDeclaredFields(); - for (Field campoEntidade : campos) { - campoEntidade.setAccessible(true); - - NaoAuditar naoAuditar = auditador.extrairAnotacao.extrairNaoAuditar(campoEntidade); - if(naoAuditar != null) { - continue; - } - - AuditarAtributo auditarAtributo = auditador.extrairAnotacao.extrairAuditarAtributo(campoEntidade); - String pattern = auditarAtributo != null && StringUtils.isNotBlank(auditarAtributo.pattern()) ? auditarAtributo.pattern() : null; + List camposAuditaveis = auditador.extrairCamposAuditaveis(classe); + for (AccessibleObject campoEntidade : camposAuditaveis) { + String pattern = auditador.extrairPattern(campoEntidade); Object valorOriginalEntidade = auditador.getValor(campoEntidade, valorOriginal, pattern); Object valorNovoEntidade = auditador.getValor(campoEntidade, valorNovo, pattern); @@ -54,8 +42,28 @@ class AuditadorEntidade { AuditadorObjects auditado = auditador.auditarCampo(campoEntidade, valorOriginalEntidade, valorNovoEntidade, localNomeClasse); if(auditado != null) { lsRetorno.add(auditado); - } + } } +// Field[] campos = classe.getDeclaredFields(); +// for (Field campoEntidade : campos) { +// campoEntidade.setAccessible(true); +// +// NaoAuditar naoAuditar = auditador.extrairAnotacao.extrairNaoAuditar(campoEntidade); +// if(naoAuditar != null) { +// continue; +// } +// +// AuditarAtributo auditarAtributo = auditador.extrairAnotacao.extrairAuditarAtributo(campoEntidade); +// String pattern = auditarAtributo != null && StringUtils.isNotBlank(auditarAtributo.pattern()) ? auditarAtributo.pattern() : null; +// +// Object valorOriginalEntidade = auditador.getValor(campoEntidade, valorOriginal, pattern); +// Object valorNovoEntidade = auditador.getValor(campoEntidade, valorNovo, pattern); +// +// AuditadorObjects auditado = auditador.auditarCampo(campoEntidade, valorOriginalEntidade, valorNovoEntidade, localNomeClasse); +// if(auditado != null) { +// lsRetorno.add(auditado); +// } +// } } } catch (Exception e) { throw new AuditadorException(e.getMessage(), e); diff --git a/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorList.java b/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorList.java index f577b314c..6d6a8fa6a 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorList.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorList.java @@ -1,6 +1,6 @@ package br.com.rjconsultores.auditador.auditadores; -import java.lang.reflect.Field; +import java.lang.reflect.AccessibleObject; import java.util.ArrayList; import java.util.Collection; import java.util.List; @@ -18,7 +18,7 @@ class AuditadorList { this.auditador = auditar; } - public List auditar(Field campo, Object original, Object novo, boolean auditarEntidades) { + public List auditar(AccessibleObject campo, Object original, Object novo, boolean auditarEntidades) { List lsRetorno = new ArrayList(); try { @@ -34,36 +34,51 @@ class AuditadorList { return lsRetorno; } - public List auditarList(Field campo, boolean auditarEntidades, + public List auditarList(AccessibleObject campo, boolean auditarEntidades, List lsOriginal, List lsNovo) throws CloneNotSupportedException { List lsRetorno = new ArrayList(); - if(isObjetosList(lsOriginal, lsNovo)) { - - List lsObjetosInseridos = new ArrayList(lsNovo); - lsObjetosInseridos.removeAll(lsOriginal); + List lsObjetosInseridos = new ArrayList(0); + List lsObjetosRemovidos = new ArrayList(0); + List lsObjetosMantidos = new ArrayList(0); + + if(lsNovo != null) { + lsObjetosInseridos.addAll(lsNovo); + if(lsOriginal != null) { + lsObjetosInseridos.removeAll(lsOriginal); + } lsRetorno.addAll(auditarRegistros(campo, lsObjetosInseridos, true)); - List lsObjetosRemovidos = new ArrayList(lsOriginal); - lsObjetosRemovidos.removeAll(lsNovo); + if(auditarEntidades) { + lsObjetosMantidos.addAll(lsNovo); + } + } + + if(lsOriginal != null) { + lsObjetosRemovidos.addAll(lsOriginal); + if(lsNovo != null) { + lsObjetosRemovidos.removeAll(lsNovo); + } lsRetorno.addAll(auditarRegistros(campo, lsObjetosRemovidos, false)); if(auditarEntidades) { - List lsObjetosMantidos = new ArrayList(lsNovo); lsObjetosMantidos.retainAll(lsOriginal); - for (Object object : lsObjetosMantidos) { - Object originalEntidade = lsOriginal.get(lsOriginal.indexOf(object)); - Object novoEntidade = lsNovo.get(lsNovo.indexOf(object)); - String nomeClasse = auditador.extrairNomeClasse(originalEntidade, novoEntidade); - - lsRetorno.addAll(auditador.auditadorEntidade.auditar(null, originalEntidade, novoEntidade, nomeClasse)); - } + } + } + + if(auditarEntidades) { + for (Object object : lsObjetosMantidos) { + Object originalEntidade = lsOriginal.get(lsOriginal.indexOf(object)); + Object novoEntidade = lsNovo.get(lsNovo.indexOf(object)); + String nomeClasse = auditador.extrairNomeClasse(originalEntidade, novoEntidade); + + lsRetorno.addAll(auditador.auditadorEntidade.auditar(null, originalEntidade, novoEntidade, nomeClasse)); } } return lsRetorno; } - protected List auditarRegistros(Field campo, List lsObjetosRemovidos, boolean inserido) + protected List auditarRegistros(AccessibleObject campo, List lsObjetosRemovidos, boolean inserido) throws CloneNotSupportedException { List lsRetorno = new ArrayList(); String nomeCampo = auditador.extrairNomeCampo(campo); @@ -83,12 +98,8 @@ class AuditadorList { return lsRetorno; } - private boolean isObjetosList(Object original, Object novo) { - if(auditador.isObjetosNulos(original, novo)) { - return false; - } - - return original instanceof Collection && novo instanceof Collection; + protected boolean isObjetosList(Object objeto) { + return objeto != null && objeto instanceof Collection; } protected AuditadorObjects auditarObjetoInserido(String nomeCampo, Object objeto) throws CloneNotSupportedException { diff --git a/src/main/java/br/com/rjconsultores/auditador/auditadores/ExtrairAnotacao.java b/src/main/java/br/com/rjconsultores/auditador/auditadores/ExtrairAnotacao.java index 84b797b32..58ec030de 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/ExtrairAnotacao.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/ExtrairAnotacao.java @@ -6,7 +6,9 @@ import br.com.rjconsultores.auditador.annotations.AuditarAtributo; import br.com.rjconsultores.auditador.annotations.AuditarClasse; import br.com.rjconsultores.auditador.annotations.AuditarEntidade; import br.com.rjconsultores.auditador.annotations.AuditarID; +import br.com.rjconsultores.auditador.annotations.AuditarIDComposta; import br.com.rjconsultores.auditador.annotations.AuditarLista; +import br.com.rjconsultores.auditador.annotations.AuditarMetodo; import br.com.rjconsultores.auditador.annotations.NaoAuditar; class ExtrairAnotacao { @@ -42,6 +44,14 @@ class ExtrairAnotacao { return campo.getAnnotation(AuditarID.class); } + protected AuditarIDComposta extrairAuditarIDComposta(AccessibleObject campo) { + if(campo == null) { + return null; + } + campo.setAccessible(true); + return campo.getAnnotation(AuditarIDComposta.class); + } + protected AuditarLista extrairAuditarLista(AccessibleObject campo) { if(campo == null) { return null; @@ -57,5 +67,13 @@ class ExtrairAnotacao { campo.setAccessible(true); return campo.getAnnotation(NaoAuditar.class); } + + protected AuditarMetodo extrairAuditarMetodo(AccessibleObject campo) { + if(campo == null) { + return null; + } + campo.setAccessible(true); + return campo.getAnnotation(AuditarMetodo.class); + } } diff --git a/src/main/java/br/com/rjconsultores/auditador/enums/TipoExtracaoDados.java b/src/main/java/br/com/rjconsultores/auditador/enums/TipoExtracaoDados.java new file mode 100644 index 000000000..bac71bdfd --- /dev/null +++ b/src/main/java/br/com/rjconsultores/auditador/enums/TipoExtracaoDados.java @@ -0,0 +1,8 @@ +package br.com.rjconsultores.auditador.enums; + +public enum TipoExtracaoDados { + + ATRIBUTO, + METODO; + +} diff --git a/src/main/java/br/com/rjconsultores/auditador/model/AuditadorObjects.java b/src/main/java/br/com/rjconsultores/auditador/model/AuditadorObjects.java index 48c752b08..77d8f0853 100644 --- a/src/main/java/br/com/rjconsultores/auditador/model/AuditadorObjects.java +++ b/src/main/java/br/com/rjconsultores/auditador/model/AuditadorObjects.java @@ -10,7 +10,6 @@ public class AuditadorObjects implements Cloneable { private String classeAlterada; private String classePrincipal; private String tela; - private Integer empresaId; private AuditadorTipoAlteracao tipoAlteracao; private String idAuditado; @@ -62,14 +61,6 @@ public class AuditadorObjects implements Cloneable { this.tela = tela; } - public Integer getEmpresaId() { - return empresaId; - } - - public void setEmpresaId(Integer empresaId) { - this.empresaId = empresaId; - } - public AuditadorTipoAlteracao getTipoAlteracao() { return tipoAlteracao; } @@ -99,7 +90,7 @@ public class AuditadorObjects implements Cloneable { public String toString() { return "AuditadorObjects [valorAnterior=" + valorAnterior + ", valorNovo=" + valorNovo + ", campoAlterado=" + campoAlterado + ", classeAlterada=" + classeAlterada + ", classePrincipal=" + classePrincipal - + ", tela=" + tela + ", empresaId=" + empresaId + ", tipoAlteracao=" + tipoAlteracao + ", idAuditado=" + + ", tela=" + tela + ", tipoAlteracao=" + tipoAlteracao + ", idAuditado=" + idAuditado + "]"; }