diff --git a/pom.xml b/pom.xml index 6af279bf1..164b56a7e 100644 --- a/pom.xml +++ b/pom.xml @@ -1,3 +1,4 @@ +<<<<<<< HEAD @@ -36,4 +37,45 @@ 2.2 - \ No newline at end of file + +======= + + 4.0.0 + br.com.rjconsultores + Auditador + 1.0.0 + + + + rj-releases + http://52.5.53.15:8081/nexus/content/repositories/releases/ + + + + + src/main/java + src/test/java + + + maven-compiler-plugin + 3.8.1 + + 1.8 + 1.8 + + + + ${project.artifactId} + + + + + commons-lang + commons-lang + 2.2 + + + +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarAtributo.java b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarAtributo.java index 27b3a81ce..74dc411a2 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarAtributo.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarAtributo.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.annotations; import java.lang.annotation.ElementType; @@ -26,3 +27,33 @@ public @interface AuditarAtributo { String pattern() default "dd/MM/yyyy HH:mm"; } +======= +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 atributos. + * + * @author wilian + * + */ +@Target(ElementType.FIELD) +@Retention(RetentionPolicy.RUNTIME) +public @interface AuditarAtributo { + + /** + * 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"; + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 2611fac44..2903ed253 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarClasse.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarClasse.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.annotations; import java.lang.annotation.ElementType; @@ -33,3 +34,40 @@ public @interface AuditarClasse { */ TipoExtracaoDados tipoExtracaoDados() default TipoExtracaoDados.ATRIBUTO; } +======= +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; + +import br.com.rjconsultores.auditador.enums.TipoExtracaoDados; + +/** + * Anotação responsável por indicar que a classe será auditada. + * + * @author wilian + * + */ +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +public @interface AuditarClasse { + + /** + * Caso seja necessário colocar um nome amigável para a classe, senão for informado o padrão será o nome da classe. + */ + String nome(); + + /** + * 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; +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 ae2370025..a18272c6e 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarEntidade.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarEntidade.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.annotations; import java.lang.annotation.Retention; @@ -18,3 +19,25 @@ public @interface AuditarEntidade { String nome() default ""; } +======= +package br.com.rjconsultores.auditador.annotations; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** + * Anotação responsável que indicará que o atributo é uma entidade e seus atributos deverão ser auditados individualmente. + * + * @author wilian + * + */ +@Retention(RetentionPolicy.RUNTIME) +public @interface AuditarEntidade { + + /** + * 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 ""; + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 6ab8916f9..76e7384a9 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarID.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarID.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.annotations; import java.lang.annotation.Retention; @@ -16,3 +17,23 @@ public @interface AuditarID { String pattern() default ""; } +======= +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 da classe. + * + * @author wilian + * + */ +@Retention(RetentionPolicy.RUNTIME) +public @interface AuditarID { + + String nome() default ""; + String pattern() default ""; + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarIDComposta.java b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarIDComposta.java index 143666170..9797354fe 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarIDComposta.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarIDComposta.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.annotations; import java.lang.annotation.Retention; @@ -13,3 +14,20 @@ import java.lang.annotation.RetentionPolicy; public @interface AuditarIDComposta { } +======= +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 { + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 0e852110e..bcf09fadc 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarLista.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarLista.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.annotations; import java.lang.annotation.Retention; @@ -24,3 +25,31 @@ public @interface AuditarLista { boolean auditarEntidades() default false; } +======= +package br.com.rjconsultores.auditador.annotations; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** + * Anotação responsável para auditar o campos que são listas. + * + * @author wilian + * + */ +@Retention(RetentionPolicy.RUNTIME) +public @interface AuditarLista { + + /** + * 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 ""; + + /** + * Indica que os atributos da lista são entidades e precisam ser auditados individualmente. O padrão é comparar apenas se os itens da lista foram removidos ou adicionados. + * @return + */ + boolean auditarEntidades() default false; + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d diff --git a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarMetodo.java b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarMetodo.java index 2a472fd5f..67ef6d970 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarMetodo.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/AuditarMetodo.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.annotations; import java.lang.annotation.ElementType; @@ -26,3 +27,33 @@ public @interface AuditarMetodo { String pattern() default "dd/MM/yyyy HH:mm"; } +======= +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"; + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 bc8d73c4f..8e6d58896 100644 --- a/src/main/java/br/com/rjconsultores/auditador/annotations/NaoAuditar.java +++ b/src/main/java/br/com/rjconsultores/auditador/annotations/NaoAuditar.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.annotations; import java.lang.annotation.Retention; @@ -13,3 +14,20 @@ import java.lang.annotation.RetentionPolicy; public @interface NaoAuditar { } +======= +package br.com.rjconsultores.auditador.annotations; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** + * 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. + * + * @author wilian + * + */ +@Retention(RetentionPolicy.RUNTIME) +public @interface NaoAuditar { + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 3219b0531..e1524a476 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/Auditador.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/Auditador.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.auditadores; import java.lang.reflect.AccessibleObject; @@ -626,3 +627,633 @@ public class Auditador { } } +======= +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; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Date; +import java.util.List; +import java.util.Locale; + +import org.apache.commons.lang.StringUtils; + +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; +import br.com.rjconsultores.auditador.model.AuditadorObjects; + +/** + * Classe responsável para listar as alterações do objeto. + * + * @author wilian + * + */ +public class Auditador { + + AuditadorAtributo auditadorAtributo; + AuditadorEntidade auditadorEntidade; + AuditadorList auditadorList; + ExtrairAnotacao extrairAnotacao; + + private AuditadorObjects padrao; + private TipoExtracaoDados tipoExtracaoDados; + + private Auditador() { + super(); + } + + public static Auditador getInstance( ) { + Auditador auditar = new Auditador(); + auditar.auditadorAtributo = new AuditadorAtributo(auditar); + auditar.auditadorEntidade = new AuditadorEntidade(auditar); + auditar.auditadorList = new AuditadorList(auditar); + auditar.extrairAnotacao = new ExtrairAnotacao(); + return auditar; + } + + /** + * Responsável por auditar os registros. + * + * @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 ? AuditadorTipoAlteracao.INCLUSAO : AuditadorTipoAlteracao.ALTERACAO)) { + return lsRetorno; + } + + AuditadorObjects objectNovo = auditarObjetoNovo(null, original, novo); + if(objectNovo != null) { + lsRetorno.add(objectNovo); + return lsRetorno; + } + + lsRetorno.addAll(auditarCampos(original, novo, padrao.getClasseAlterada())); + return lsRetorno; + } catch (Exception e) { + throw new AuditadorException(e.getMessage(), e); + } catch (Throwable e) { + throw new AuditadorException(e.getMessage(), e); + } + } + + /** + * 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 + * + * @param objeto + * @param nomeCampoListAuditar + * @param original + * @param novo + * @return + */ + public List auditarList(Object objeto, String nomeCampoListAuditar, List original, List novo) { + List lsRetorno = new ArrayList(); + try { + 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); + } catch (Throwable e) { + throw new AuditadorException(e.getMessage(), e); + } + return lsRetorno; + } + + /** + * 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, AuditadorTipoAlteracao.EXCLUSAO)) { + return lsRetorno; + } + + AuditadorObjects objetoExcluido = auditarObjetoExcluido(objeto); + if(objetoExcluido != null) { + lsRetorno.add(objetoExcluido); + } + + return lsRetorno; + } catch (Exception e) { + throw new AuditadorException(e.getMessage(), e); + } catch (Throwable e) { + throw new AuditadorException(e.getMessage(), e); + } + } + + /** + * 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))); + auditado.setCampoAlterado(extrairNomeCampo(campo)); + return auditado; + } + return null; + } + + protected AuditadorObjects auditarObjetoPersonalizado(Object objeto, AuditadorTipoAlteracao tipoAlteracao, String valorNovo) throws CloneNotSupportedException { + if(objeto != null) { + AuditadorObjects auditado = padrao.clonar(); + auditado.setTipoAlteracao(tipoAlteracao != null ? tipoAlteracao : AuditadorTipoAlteracao.ALTERACAO); + auditado.setValorNovo(String.format("%s [%s]", valorNovo, extrairTextoInclusaoExclusao(objeto))); + return auditado; + } + return null; + } + + 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(); + auditado.setTipoAlteracao(AuditadorTipoAlteracao.ALTERACAO); + auditado.setCampoAlterado(nomeCampo); + auditado.setValorAnterior(valorOriginal != null ? valorOriginal.toString() : null); + auditado.setValorNovo(valorNovo != null ? valorNovo.toString() : null); + auditado.setClasseAlterada(nomeClasse); + return auditado; + } + return null; + } + + protected String extrairNomeClasse(Object original, Object novo) { + if(original != null) { + return original.getClass().getSimpleName(); + } + if(novo != null) { + return novo.getClass().getSimpleName(); + } + return null; + } + + 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; + } + + if(valorOriginal != null && valorNovo == null) { + return true; + } + + if(valorOriginal == null && valorNovo != null) { + return true; + } + + return !valorOriginal.equals(valorNovo); + } + + protected List auditarCampos(Object original, Object novo, String nomeClasse) throws IllegalArgumentException, IllegalAccessException { + List lsRetorno = new ArrayList(); + if(!isObjetosNulos(original, novo)) { + Class classe = original != null ? original.getClass() : novo.getClass(); + List camposAuditaveis = extrairCamposAuditaveis(classe); + for (AccessibleObject campo : camposAuditaveis) { + AuditarEntidade auditarEntidade = extrairAnotacao.extrairAuditarEntidade(campo); + AuditarLista auditarLista = extrairAnotacao.extrairAuditarLista(campo); + + if(auditarEntidade != null) { + lsRetorno.addAll(auditadorEntidade.auditar(campo, original, novo, null)); + } else if(auditarLista != null) { + lsRetorno.addAll(auditadorList.auditar(campo, original, novo, auditarLista.auditarEntidades())); + } else { + lsRetorno.addAll(auditadorAtributo.auditar(campo, original, novo, nomeClasse)); + } + } + } + return lsRetorno; + + } + + 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(AccessibleObject campo, Object object, String pattern) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException { + if(campo == null || object == null) { + return null; + } + Object retorno = extrairValor(campo, object); + + Object atributo = null; + if (retorno instanceof Date) { + Date aux = (Date) retorno; + + atributo = getStringDate(aux, pattern); + } else if (retorno instanceof Integer || retorno instanceof Long ) { + atributo = retorno.toString(); + } else if (retorno instanceof Number) { + atributo = getValorFormatado(retorno.toString()); + } else if(retorno instanceof String) { + atributo = StringUtils.isNotBlank(retorno.toString()) ? retorno.toString() : "nulo"; + } else { + return retorno; + } + return atributo; + + } + + protected String getValorFormatado(String value) throws ParseException { + + if(value != null && StringUtils.isNotBlank(value)) { + NumberFormat nf = NumberFormat.getInstance(new Locale("pt", "br")); + BigDecimal valor = new BigDecimal(nf.parse(value.replace(".", ",")).toString()); + + return nf.format(valor.doubleValue()); + } + + return null; + } + + protected String getStringDate(java.util.Date d, String pattern) { + if(StringUtils.isBlank(pattern)) { + pattern = "dd/MM/yyyy HH:mm"; + } + + SimpleDateFormat sdf = new SimpleDateFormat(pattern); + if (d != null) { + return sdf.format(d); + } + return null; + } + + @SuppressWarnings("unchecked") + protected List getValorList(AccessibleObject campo, Object object) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException { + if(campo == null || object == null) { + return new ArrayList(); + } + Object aux = extrairValor(campo, object); + + List retorno = new ArrayList(); + if(aux != null && aux instanceof Collection) { + retorno.addAll((Collection) aux); + } + + return retorno; + } + + protected boolean isObjetosNulos(Object original, Object novo) { + return novo == null && original == null; + } + + protected boolean isObjetoNovo(Object original, Object novo) { + return novo != null && original == null; + } + + 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(tipoAlteracao); + padrao.setTela(getNomeTela(auditarClasse, objeto)); + padrao.setIdAuditado(getIdEntidade(objeto)); + padrao.setClassePrincipal(StringUtils.isNotBlank(auditarClasse.nome()) ? auditarClasse.nome() : classe.getSimpleName()); + + } + return padrao != null; + } + + protected String getNomeTela(AuditarClasse auditarClasse, Object objeto) { + if(objeto instanceof AuditavelTelaAlternativa) { + AuditavelTelaAlternativa aux = (AuditavelTelaAlternativa) objeto; + if(aux != null && StringUtils.isNotBlank(aux.getTelaAlternativa())) { + return aux.getTelaAlternativa(); + } + } + return auditarClasse.tela(); + } + + protected String getIdEntidade(Object objeto) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException { + Object valor = null; + Class classe = objeto.getClass(); + 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()); + } + + if(valor == null) { + AuditarIDComposta auditarIDComposta = extrairAnotacao.extrairAuditarIDComposta(campo); + if(auditarIDComposta != null) { + valor = getIdEntidadeComposta(campo, objeto); + } + } + + } + return valor != null ? valor.toString() : null; + } + + 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 sb.length() > 0 ? sb.toString() : null; + } + + protected AuditadorObjects getPadrao() { + try { + return padrao.clonar(); + } catch (Exception e) { + throw new AuditadorException("Não foi possível clonar o objeto padrão", e); + } + } + + protected String extrairTextoInclusaoExclusao(Object objeto) { + if(objeto instanceof Auditavel) { + Auditavel auditavelAux = (Auditavel) objeto; + return auditavelAux.getTextoInclusaoExclusao(); + } + 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; + } + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 a81cc05c0..3321fd6a6 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorAtributo.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorAtributo.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.auditadores; import java.lang.reflect.AccessibleObject; @@ -40,3 +41,47 @@ class AuditadorAtributo { } } +======= +package br.com.rjconsultores.auditador.auditadores; + +import java.lang.reflect.AccessibleObject; +import java.util.ArrayList; +import java.util.List; + +import br.com.rjconsultores.auditador.exceptions.AuditadorException; +import br.com.rjconsultores.auditador.model.AuditadorObjects; + +class AuditadorAtributo { + + protected Auditador auditador; + + public AuditadorAtributo(Auditador auditar) { + super(); + this.auditador = auditar; + } + + public List auditar(AccessibleObject campo, Object original, Object novo, String nomeClasse) { + List lsRetorno = new ArrayList(); + try { + + if(!auditador.isObjetosNulos(original, novo)) { + String pattern = auditador.extrairPattern(campo); + + Object valorOriginal = auditador.getValor(campo, original, pattern); + Object valorNovo = auditador.getValor(campo, novo, pattern); + AuditadorObjects auditado = auditador.auditarCampo(campo, valorOriginal, valorNovo, nomeClasse); + if(auditado != null) { + lsRetorno.add(auditado); + } + } + + } catch (Exception e) { + throw new AuditadorException(e.getMessage(), e); + } catch (Throwable e) { + throw new AuditadorException(e.getMessage(), e); + } + return lsRetorno; + } + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 45bf41cec..5e22d5fd3 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorEntidade.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorEntidade.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.auditadores; import java.lang.reflect.AccessibleObject; @@ -74,3 +75,81 @@ class AuditadorEntidade { } } +======= +package br.com.rjconsultores.auditador.auditadores; + +import java.lang.reflect.AccessibleObject; +import java.util.ArrayList; +import java.util.List; + +import br.com.rjconsultores.auditador.exceptions.AuditadorException; +import br.com.rjconsultores.auditador.model.AuditadorObjects; + +class AuditadorEntidade { + + protected Auditador auditador; + + public AuditadorEntidade(Auditador auditar) { + super(); + this.auditador = auditar; + } + + public List auditar(AccessibleObject campo, Object original, Object novo, String nomeClasse) { + List lsRetorno = new ArrayList(); + try { + 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); + + AuditadorObjects objectNovo = auditador.auditarObjetoNovo(campo, valorOriginal, valorNovo); + if(objectNovo != null) { + lsRetorno.add(objectNovo); + return lsRetorno; + } + + if(!auditador.isObjetosNulos(valorOriginal, valorNovo)) { + Class classe = valorOriginal != null ? valorOriginal.getClass() : valorNovo.getClass(); + 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); + + 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); + } catch (Throwable e) { + throw new AuditadorException(e.getMessage(), e); + } + return lsRetorno; + } + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 6d6a8fa6a..1fff6c130 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorList.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorList.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.auditadores; import java.lang.reflect.AccessibleObject; @@ -129,3 +130,136 @@ class AuditadorList { } } +======= +package br.com.rjconsultores.auditador.auditadores; + +import java.lang.reflect.AccessibleObject; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import br.com.rjconsultores.auditador.enums.AuditadorTipoAlteracao; +import br.com.rjconsultores.auditador.exceptions.AuditadorException; +import br.com.rjconsultores.auditador.model.AuditadorObjects; + +class AuditadorList { + + protected Auditador auditador; + + public AuditadorList(Auditador auditar) { + super(); + this.auditador = auditar; + } + + public List auditar(AccessibleObject campo, Object original, Object novo, boolean auditarEntidades) { + List lsRetorno = new ArrayList(); + try { + + List lsOriginal = auditador.getValorList(campo, original); + List lsNovo = auditador.getValorList(campo, novo); + + lsRetorno.addAll(auditarList(campo, auditarEntidades, lsOriginal, lsNovo)); + } catch (Exception e) { + throw new AuditadorException(e.getMessage(), e); + } catch (Throwable e) { + throw new AuditadorException(e.getMessage(), e); + } + return lsRetorno; + } + + public List auditarList(AccessibleObject campo, boolean auditarEntidades, + List lsOriginal, List lsNovo) throws CloneNotSupportedException { + List lsRetorno = new ArrayList(); + + 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)); + + 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) { + lsObjetosMantidos.retainAll(lsOriginal); + } + } + + 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(AccessibleObject campo, List lsObjetosRemovidos, boolean inserido) + throws CloneNotSupportedException { + List lsRetorno = new ArrayList(); + String nomeCampo = auditador.extrairNomeCampo(campo); + for (Object removido : lsObjetosRemovidos) { + AuditadorObjects objectInserido = null; + + if(inserido) { + objectInserido = auditarObjetoInserido(nomeCampo, removido); + } else { + objectInserido = auditarObjetoRemovido(nomeCampo, removido); + } + + if(objectInserido != null) { + lsRetorno.add(objectInserido); + } + } + return lsRetorno; + } + + protected boolean isObjetosList(Object objeto) { + return objeto != null && objeto instanceof Collection; + } + + protected AuditadorObjects auditarObjetoInserido(String nomeCampo, Object objeto) throws CloneNotSupportedException { + if(objeto != null) { + AuditadorObjects auditado = criarObjetoInseridoRemovido(nomeCampo, objeto); + auditado.setValorNovo(String.format("Registro inserido [%s]", auditador.extrairTextoInclusaoExclusao(objeto))); + return auditado; + } + return null; + } + + private AuditadorObjects criarObjetoInseridoRemovido(String nomeCampo, Object objeto) throws CloneNotSupportedException { + AuditadorObjects auditado = auditador.getPadrao().clonar(); + auditado.setTipoAlteracao(AuditadorTipoAlteracao.ALTERACAO); + auditado.setCampoAlterado(nomeCampo); + auditado.setClasseAlterada(objeto.getClass().getSimpleName()); + return auditado; + } + + protected AuditadorObjects auditarObjetoRemovido(String nomeCampo, Object objeto) throws CloneNotSupportedException { + if(objeto != null) { + AuditadorObjects auditado = criarObjetoInseridoRemovido(nomeCampo, objeto); + auditado.setValorNovo(String.format("Registro removido [%s]", auditador.extrairTextoInclusaoExclusao(objeto))); + return auditado; + } + return null; + } + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 58ec030de..cc963170f 100644 --- a/src/main/java/br/com/rjconsultores/auditador/auditadores/ExtrairAnotacao.java +++ b/src/main/java/br/com/rjconsultores/auditador/auditadores/ExtrairAnotacao.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.auditadores; import java.lang.reflect.AccessibleObject; @@ -77,3 +78,84 @@ class ExtrairAnotacao { } } +======= +package br.com.rjconsultores.auditador.auditadores; + +import java.lang.reflect.AccessibleObject; + +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 { + + protected AuditarClasse extrair(Class classe) { + if(classe == null) { + return null; + } + return classe.getAnnotation(AuditarClasse.class); + } + + protected AuditarAtributo extrairAuditarAtributo(AccessibleObject campo) { + if(campo == null) { + return null; + } + campo.setAccessible(true); + return campo.getAnnotation(AuditarAtributo.class); + } + + protected AuditarEntidade extrairAuditarEntidade(AccessibleObject campo) { + if(campo == null) { + return null; + } + campo.setAccessible(true); + return campo.getAnnotation(AuditarEntidade.class); + } + + protected AuditarID extrairAuditarID(AccessibleObject campo) { + if(campo == null) { + return null; + } + campo.setAccessible(true); + 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; + } + campo.setAccessible(true); + return campo.getAnnotation(AuditarLista.class); + } + + protected NaoAuditar extrairNaoAuditar(AccessibleObject campo) { + if(campo == null) { + return null; + } + 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); + } + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d diff --git a/src/main/java/br/com/rjconsultores/auditador/enums/AuditadorTipoAlteracao.java b/src/main/java/br/com/rjconsultores/auditador/enums/AuditadorTipoAlteracao.java index 411433ff9..d09de8b3c 100644 --- a/src/main/java/br/com/rjconsultores/auditador/enums/AuditadorTipoAlteracao.java +++ b/src/main/java/br/com/rjconsultores/auditador/enums/AuditadorTipoAlteracao.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.enums; import java.util.Arrays; @@ -14,3 +15,21 @@ public enum AuditadorTipoAlteracao { } } +======= +package br.com.rjconsultores.auditador.enums; + +import java.util.Arrays; +import java.util.List; + +public enum AuditadorTipoAlteracao { + + INCLUSAO, + ALTERACAO, + EXCLUSAO; + + public static List getList() { + return Arrays.asList(values()); + } + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d diff --git a/src/main/java/br/com/rjconsultores/auditador/enums/TipoExtracaoDados.java b/src/main/java/br/com/rjconsultores/auditador/enums/TipoExtracaoDados.java index bac71bdfd..22e75558f 100644 --- a/src/main/java/br/com/rjconsultores/auditador/enums/TipoExtracaoDados.java +++ b/src/main/java/br/com/rjconsultores/auditador/enums/TipoExtracaoDados.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.enums; public enum TipoExtracaoDados { @@ -6,3 +7,13 @@ public enum TipoExtracaoDados { METODO; } +======= +package br.com.rjconsultores.auditador.enums; + +public enum TipoExtracaoDados { + + ATRIBUTO, + METODO; + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d diff --git a/src/main/java/br/com/rjconsultores/auditador/exceptions/AuditadorException.java b/src/main/java/br/com/rjconsultores/auditador/exceptions/AuditadorException.java index 4110ae5e6..ed0c9e3c1 100644 --- a/src/main/java/br/com/rjconsultores/auditador/exceptions/AuditadorException.java +++ b/src/main/java/br/com/rjconsultores/auditador/exceptions/AuditadorException.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.exceptions; public class AuditadorException extends RuntimeException { @@ -9,3 +10,16 @@ public class AuditadorException extends RuntimeException { } } +======= +package br.com.rjconsultores.auditador.exceptions; + +public class AuditadorException extends RuntimeException { + + private static final long serialVersionUID = 1L; + + public AuditadorException(String message, Throwable throwable) { + super(message, throwable); + } + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d diff --git a/src/main/java/br/com/rjconsultores/auditador/interfaces/Auditavel.java b/src/main/java/br/com/rjconsultores/auditador/interfaces/Auditavel.java index a21d4760f..0f8098a3d 100644 --- a/src/main/java/br/com/rjconsultores/auditador/interfaces/Auditavel.java +++ b/src/main/java/br/com/rjconsultores/auditador/interfaces/Auditavel.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.interfaces; /** @@ -31,3 +32,38 @@ public interface Auditavel extends Cloneable { public String getTextoInclusaoExclusao(); } +======= +package br.com.rjconsultores.auditador.interfaces; + +/** + * Interface que deverá ser implementada quando o objeto for auditado, interface estende a interface Cloneable. + * + * @author wilian + * + * @param + */ +public interface Auditavel extends Cloneable { + + /** + * Método deverá ser implementado com o recurso de clonagem da Interface Cloneable. Executa o processo de clonagem do objeto para ser comparado com o alterado, executar esse método logo após recuperar o objeto do banco de dados. + * + * @throws CloneNotSupportedException + */ + public void clonar() throws CloneNotSupportedException; + + /** + * Após executar o método "clonar" retorna o objeto clonado. + * + * @return + * @throws CloneNotSupportedException + */ + public T getCloneObject() throws CloneNotSupportedException; + + /** + * Método que descreve informações do objeto quando o registro é criado/incluído/excluído. + * @return + */ + public String getTextoInclusaoExclusao(); + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d diff --git a/src/main/java/br/com/rjconsultores/auditador/interfaces/AuditavelTelaAlternativa.java b/src/main/java/br/com/rjconsultores/auditador/interfaces/AuditavelTelaAlternativa.java index 24a01d879..aa135697f 100644 --- a/src/main/java/br/com/rjconsultores/auditador/interfaces/AuditavelTelaAlternativa.java +++ b/src/main/java/br/com/rjconsultores/auditador/interfaces/AuditavelTelaAlternativa.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.interfaces; /** @@ -16,3 +17,23 @@ public interface AuditavelTelaAlternativa { public String getTelaAlternativa(); } +======= +package br.com.rjconsultores.auditador.interfaces; + +/** + * Interface que permite informar uma tela alternativa para auditoria do objeto quando o mesmo é alterado em telas diferentes. + * + * @author wilian + * + */ +public interface AuditavelTelaAlternativa { + + /** + * Quando o objeto auditado implementar a interface, o valor do retorno desse método será priorizado. + * + * @return + */ + public String getTelaAlternativa(); + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d 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 77d8f0853..0bff12812 100644 --- a/src/main/java/br/com/rjconsultores/auditador/model/AuditadorObjects.java +++ b/src/main/java/br/com/rjconsultores/auditador/model/AuditadorObjects.java @@ -1,3 +1,4 @@ +<<<<<<< HEAD package br.com.rjconsultores.auditador.model; import br.com.rjconsultores.auditador.enums.AuditadorTipoAlteracao; @@ -95,3 +96,102 @@ public class AuditadorObjects implements Cloneable { } } +======= +package br.com.rjconsultores.auditador.model; + +import br.com.rjconsultores.auditador.enums.AuditadorTipoAlteracao; + +public class AuditadorObjects implements Cloneable { + + private String valorAnterior; + private String valorNovo; + private String campoAlterado; + private String classeAlterada; + private String classePrincipal; + private String tela; + private AuditadorTipoAlteracao tipoAlteracao; + private String idAuditado; + + public String getValorAnterior() { + return valorAnterior; + } + + public void setValorAnterior(String valorAnterior) { + this.valorAnterior = valorAnterior; + } + + public String getValorNovo() { + return valorNovo; + } + + public void setValorNovo(String valorNovo) { + this.valorNovo = valorNovo; + } + + public String getCampoAlterado() { + return campoAlterado; + } + + public void setCampoAlterado(String campoAlterado) { + this.campoAlterado = campoAlterado; + } + + public String getClasseAlterada() { + return classeAlterada; + } + + public void setClasseAlterada(String classeAlterada) { + this.classeAlterada = classeAlterada; + } + + public String getClassePrincipal() { + return classePrincipal; + } + + public void setClassePrincipal(String classePrincipal) { + this.classePrincipal = classePrincipal; + } + + public String getTela() { + return tela; + } + + public void setTela(String tela) { + this.tela = tela; + } + + public AuditadorTipoAlteracao getTipoAlteracao() { + return tipoAlteracao; + } + + public void setTipoAlteracao(AuditadorTipoAlteracao tipoAlteracao) { + this.tipoAlteracao = tipoAlteracao; + } + + public String getIdAuditado() { + return idAuditado; + } + + public void setIdAuditado(String idAuditado) { + this.idAuditado = idAuditado; + } + + @Override + protected Object clone() throws CloneNotSupportedException { + return super.clone(); + } + + public AuditadorObjects clonar() throws CloneNotSupportedException { + return (AuditadorObjects) this.clone(); + } + + @Override + public String toString() { + return "AuditadorObjects [valorAnterior=" + valorAnterior + ", valorNovo=" + valorNovo + ", campoAlterado=" + + campoAlterado + ", classeAlterada=" + classeAlterada + ", classePrincipal=" + classePrincipal + + ", tela=" + tela + ", tipoAlteracao=" + tipoAlteracao + ", idAuditado=" + + idAuditado + "]"; + } + +} +>>>>>>> cdb83713aef1ad0033f6129385ee0bda81737f2d