| /branches/v3/impl/src/java/pt/estgp/estgweb/domain/CourseUnitImpl.java |
|---|
| 1,6 → 1,7 |
| package pt.estgp.estgweb.domain; |
| import com.owlike.genson.Genson; |
| import com.owlike.genson.GensonBuilder; |
| import org.apache.log4j.Logger; |
| import pt.estgp.estgweb.Globals; |
| import pt.estgp.estgweb.domain.dao.DaoFactory; |
| 677,17 → 678,23 |
| protected String dsTipologia; |
| protected Integer ocorrencias = 0; // apenas faz sentido nos sumarios. no horario ref nao. |
| protected boolean tdocturma = false; |
| //NOVO NESTE MOMENTO NAS TIPOLOGIAS APENAS O EXCLUDED É UTILIZADO |
| //O USE NAO É UTILIZADO, APENAS EM REAL TIME PARA VER SE SE USA OU NAO UMA TIPO |
| //NOS METODOS DE MERGE, POR EXEMPLO SO SE USAM AS QUE TEM SUMARIO, NAS SIMPES |
| //TODAS AS GERADAS SE USAM |
| //O MARKWARNING É USADO EM REAL TIME QUANDO UM AVISO É ENCONTRADO |
| //AS extras e as horarioRef são marcadas em tempo real caso estejam numa lista |
| //ou noutra assim como as tdocturma |
| protected boolean exclude = false; |
| protected boolean use; //campo auxiliar para marcar se vai ser ou não usada nas afetacoes especificas |
| //por omissão apenas as que têm sumários |
| protected boolean markWarning; //campo auxiliar para marcar se vai ser ou não usada nas afetacoes especificas |
| protected boolean extra; |
| protected boolean horRef; |
| protected boolean tdocturma = false; |
| //NOVO |
| protected boolean exclude = false; |
| public boolean isTdocturma() { |
| return tdocturma; |
| } |
| 895,7 → 902,7 |
| tipoExtra.cdTipologia = Globals.BACO_TIPOLOGIA_SIMPLES_VIRTUAL_CODE; |
| tipoExtra.dsTipologia = Globals.BACO_TIPOLOGIA_SIMPLES_DS; |
| tipoExtra.extra = true; |
| tipoExtra.exclude = true; |
| tipoExtra.exclude = excluded; |
| if(tipoClass.getTipologiasExtraAdicionadas() == null) |
| tipoClass.setTipologiasExtraAdicionadas(new ArrayList<Tipologia>()); |
| tipoClass.getTipologiasExtraAdicionadas().add(tipoExtra); |
| 974,7 → 981,7 |
| public void setTipologiasMarcadas(ArrayList<Tipologia> tipologiasMarcadas) { this.tipologiasMarcadas = tipologiasMarcadas; } |
| private static Genson getGenson(){ |
| Genson genson = new Genson.Builder() |
| Genson genson = new GensonBuilder() |
| .exclude(Object.class) |
| .include(Boolean.class) |
| .include(Integer.class) |
| 998,6 → 1005,7 |
| return genson; |
| } |
| private static Genson getGensonMergedTipologiasComplete(){ |
| Genson genson = new Genson.Builder() |
| .exclude(Object.class) |
| 1043,6 → 1051,7 |
| new TestCourseUnit().testTipologias(); |
| } |
| /* Metodos em plenos funcionamento mas não sao usados para simplificar revisões foram comentados |
| public static String serializeMergedList(ArrayList<Tipologia> tipologias) throws IOException |
| { |
| MergedTipologias mergedTipologias = new MergedTipologias(); |
| 1055,6 → 1064,8 |
| return genson.serialize(mergedTipologias); |
| } |
| */ |
| /* |
| public static ArrayList<Tipologia> deserializeMergedTipologias(String serial) throws IOException |
| { |
| if(serial == null) |
| 1067,10 → 1078,13 |
| } |
| */ |
| /* |
| public String obtainMergeTipologiasSerialized() throws IOException |
| { |
| return serializeMergedList(obtainMergeTipologias()); |
| } |
| */ |
| /branches/v3/impl/src/java/pt/estgp/estgweb/domain/test/TestCourseUnit.java |
|---|
| 401,13 → 401,13 |
| t.setCdTurma("TINF"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("T"); |
| t.setOcorrencias(10); |
| t.setOcorrenciasGetSetNormal(10); |
| ts.getTipologiasSumarios().add(t); |
| t = new Tipologia(); |
| t.setCdTurma("TINF"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("TP"); |
| t.setOcorrencias(20); |
| t.setOcorrenciasGetSetNormal(20); |
| ts.getTipologiasSumarios().add(t); |
| */ |
| 464,7 → 464,7 |
| assertFalse(tipologia.isHorRef()); |
| assertTrue(tipologia.isSumario()); |
| assertFalse(tipologia.isExtra()); |
| assertTrue(tipologia.getOcorrencias() == 20); |
| assertTrue(tipologia.getOcorrenciasGetSetNormal() == 20); |
| foundTP = true; |
| }*/ |
| } |
| 509,13 → 509,13 |
| t.setCdTurma("TINF2"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("OT"); |
| t.setOcorrencias(null); |
| t.setOcorrenciasGetSetNormal(null); |
| ts.getTipologiasExtraAdicionadas().add(t); |
| t = new Tipologia(); |
| t.setCdTurma("TINF2"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("Sem"); |
| t.setOcorrencias(null); |
| t.setOcorrenciasGetSetNormal(null); |
| ts.getTipologiasExtraAdicionadas().add(t); |
| */ |
| 526,13 → 526,13 |
| t.setCdTurma("TINF"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("T"); |
| t.setOcorrencias(10); |
| t.setOcorrenciasGetSetNormal(10); |
| ts.getTipologiasSumarios().add(t); |
| t = new Tipologia(); |
| t.setCdTurma("TINF"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("TP"); |
| t.setOcorrencias(20); |
| t.setOcorrenciasGetSetNormal(20); |
| ts.getTipologiasSumarios().add(t); |
| */ |
| 573,7 → 573,7 |
| assertFalse(tipologia.isHorRef()); |
| assertFalse(tipologia.isSumario()); |
| assertTrue(tipologia.isExtra()); |
| assertTrue(tipologia.getOcorrencias() == null || tipologia.getOcorrencias() == 0); |
| assertTrue(tipologia.getOcorrenciasGetSetNormal() == null || tipologia.getOcorrenciasGetSetNormal() == 0); |
| foundOT = true; |
| } |
| if(tipologia.getCdTipologia().equals("Sem")) |
| 581,7 → 581,7 |
| assertFalse(tipologia.isHorRef()); |
| assertFalse(tipologia.isSumario()); |
| assertTrue(tipologia.isExtra()); |
| assertTrue(tipologia.getOcorrencias() == null || tipologia.getOcorrencias() == 0); |
| assertTrue(tipologia.getOcorrenciasGetSetNormal() == null || tipologia.getOcorrenciasGetSetNormal() == 0); |
| foundSem = true; |
| }*/ |
| /*if(tipologia.getCdTipologia().equals("TP")) |
| 589,7 → 589,7 |
| assertFalse(tipologia.isHorRef()); |
| assertTrue(tipologia.isSumario()); |
| assertFalse(tipologia.isExtra()); |
| assertTrue(tipologia.getOcorrencias() == 20); |
| assertTrue(tipologia.getOcorrenciasGetSetNormal() == 20); |
| foundTP = true; |
| }*/ |
| } |
| 620,13 → 620,13 |
| t.setCdTurma("TINF"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("T"); |
| t.setOcorrencias(null); |
| t.setOcorrenciasGetSetNormal(null); |
| ts.getTipologiasHorarioReferencia().add(t); |
| t = new Tipologia(); |
| t.setCdTurma("TINF"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("PL"); |
| t.setOcorrencias(null); |
| t.setOcorrenciasGetSetNormal(null); |
| ts.getTipologiasHorarioReferencia().add(t); |
| */ |
| 635,13 → 635,13 |
| t.setCdTurma("TINF2"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("OT"); |
| t.setOcorrencias(null); |
| t.setOcorrenciasGetSetNormal(null); |
| ts.getTipologiasExtraAdicionadas().add(t); |
| t = new Tipologia(); |
| t.setCdTurma("TINF2"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("Sem"); |
| t.setOcorrencias(null); |
| t.setOcorrenciasGetSetNormal(null); |
| ts.getTipologiasExtraAdicionadas().add(t); |
| */ |
| 652,13 → 652,13 |
| t.setCdTurma("TINF"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("T"); |
| t.setOcorrencias(10); |
| t.setOcorrenciasGetSetNormal(10); |
| ts.getTipologiasSumarios().add(t); |
| t = new Tipologia(); |
| t.setCdTurma("TINF"); |
| t.setCdDocente("20128"); |
| t.setCdTipologia("TP"); |
| t.setOcorrencias(20); |
| t.setOcorrenciasGetSetNormal(20); |
| ts.getTipologiasSumarios().add(t); |
| */ |
| 684,7 → 684,7 |
| assertTrue(tipologia.isHorRef()); |
| assertTrue(tipologia.isSumario()); |
| assertFalse(tipologia.isExtra()); |
| assertTrue(tipologia.getOcorrencias() == 10); |
| assertTrue(tipologia.getOcorrenciasGetSetNormal() == 10); |
| foundT = true; |
| } |
| if(tipologia.getCdTipologia().equals("PL")) |
| 692,7 → 692,7 |
| assertTrue(tipologia.isHorRef()); |
| assertFalse(tipologia.isSumario()); |
| assertFalse(tipologia.isExtra()); |
| assertTrue(tipologia.getOcorrencias() == null || tipologia.getOcorrencias() == 0); |
| assertTrue(tipologia.getOcorrenciasGetSetNormal() == null || tipologia.getOcorrenciasGetSetNormal() == 0); |
| foundPL = true; |
| } |
| */ |
| 701,7 → 701,7 |
| assertFalse(tipologia.isHorRef()); |
| assertFalse(tipologia.isSumario()); |
| assertTrue(tipologia.isExtra()); |
| assertTrue(tipologia.getOcorrencias() == null || tipologia.getOcorrencias() == 0); |
| assertTrue(tipologia.getOcorrenciasGetSetNormal() == null || tipologia.getOcorrenciasGetSetNormal() == 0); |
| foundOT = true; |
| } |
| if(tipologia.getCdTipologia().equals("Sem")) |
| 709,7 → 709,7 |
| assertFalse(tipologia.isHorRef()); |
| assertFalse(tipologia.isSumario()); |
| assertTrue(tipologia.isExtra()); |
| assertTrue(tipologia.getOcorrencias() == null || tipologia.getOcorrencias() == 0); |
| assertTrue(tipologia.getOcorrenciasGetSetNormal() == null || tipologia.getOcorrenciasGetSetNormal() == 0); |
| foundSem = true; |
| }*/ |
| /*if(tipologia.getCdTipologia().equals("TP")) |
| 717,7 → 717,7 |
| assertFalse(tipologia.isHorRef()); |
| assertTrue(tipologia.isSumario()); |
| assertFalse(tipologia.isExtra()); |
| assertTrue(tipologia.getOcorrencias() == 20); |
| assertTrue(tipologia.getOcorrenciasGetSetNormal() == 20); |
| foundTP = true; |
| }*/ |
| } |
| 735,6 → 735,8 |
| } |
| /* Metodo Serialize Merge comentado porque o serializeMerge não era usado |
| Mas está em pleno funcionamento pode voltar a ser usado |
| public void testSerializeMerge() |
| { |
| 907,6 → 909,79 |
| } |
| */ |
| public void testOnlySerialization() throws IOException { |
| ArrayList<Tipologia> ts = new ArrayList<Tipologia>(); |
| Tipologia t = new Tipologia(); |
| t.setCdTurma("1"); |
| t.setDsTipologia("2"); |
| t.setCdTipologia("3"); |
| t.setCdDocente("4"); |
| t.setOcorrencias(5); |
| t.setTdocturma(true); |
| t.setExclude(true); |
| //Estes campo nunca são serializados sao usados sim em tempo real |
| //O use por exemplo para quando faz merge perceber se usa ou não determinada |
| //Tipologia |
| t.setUse(true); |
| t.setMarkWarning(true); |
| //t.extra = ?? |
| //t.horarioRef = ?? |
| ts.add(t); |
| Tipologias tipologias = new Tipologias(); |
| tipologias.setTipologiasSumarios(ts); |
| tipologias.setTipologiasExtraAdicionadas(ts); |
| tipologias.setTipologiasUsadas(ts); |
| tipologias.setTipologiasHorarioReferencia(ts); |
| tipologias.setTipologiasTdocTurma(ts); |
| tipologias.setTipologiasMarcadas(ts); |
| String json = tipologias.serialize(); |
| Tipologias tipologias2 = Tipologias.deserialize(json); |
| Tipologia tipologiaOriginal = tipologias.getTipologiasSumarios().get(0); |
| Tipologia tipologiaObtida = tipologias2.getTipologiasSumarios().get(0); |
| checkFields(tipologiaOriginal, tipologiaObtida); |
| tipologiaObtida = tipologias2.getTipologiasExtraAdicionadas().get(0); |
| checkFields(tipologiaOriginal, tipologiaObtida); |
| tipologiaObtida = tipologias2.getTipologiasHorarioReferencia().get(0); |
| checkFields(tipologiaOriginal, tipologiaObtida); |
| tipologiaObtida = tipologias2.getTipologiasMarcadas().get(0); |
| checkFields(tipologiaOriginal, tipologiaObtida); |
| tipologiaObtida = tipologias2.getTipologiasTdocTurma().get(0); |
| checkFields(tipologiaOriginal, tipologiaObtida); |
| tipologiaObtida = tipologias2.getTipologiasUsadas().get(0); |
| checkFields(tipologiaOriginal, tipologiaObtida); |
| } |
| private void checkFields(Tipologia tipologiaOriginal, Tipologia tipologiaObtida) { |
| assertTrue(tipologiaOriginal.getCdTurma().equals(tipologiaObtida.getCdTurma())); |
| assertTrue(tipologiaOriginal.getDsTipologia().equals(tipologiaObtida.getDsTipologia())); |
| assertTrue(tipologiaOriginal.getCdTipologia().equals(tipologiaObtida.getCdTipologia())); |
| assertTrue(tipologiaOriginal.getCdDocente().equals(tipologiaObtida.getCdDocente())); |
| assertTrue(tipologiaOriginal.getOcorrencias().intValue() == tipologiaObtida.getOcorrencias().intValue()); |
| assertTrue(tipologiaOriginal.isTdocturma() == tipologiaObtida.isTdocturma()); |
| assertTrue(tipologiaOriginal.isExclude() == tipologiaObtida.isExclude()); |
| } |
| } |
| /branches/v3/impl/src/java/pt/estgp/estgweb/domain/test/genson/TestFieldsAndMethodsTogether.java |
|---|
| New file |
| 0,0 → 1,303 |
| package pt.estgp.estgweb.domain.test.genson; |
| import com.owlike.genson.Genson; |
| import com.owlike.genson.GensonBuilder; |
| import junit.framework.TestCase; |
| import org.json.JSONException; |
| import org.json.JSONObject; |
| import java.util.Date; |
| /** |
| * Created by jorgemachado on 19/06/17. |
| */ |
| public class TestFieldsAndMethodsTogether extends TestCase |
| { |
| private Date saveDate; |
| public Date getSaveDate() { |
| return saveDate; |
| } |
| public void setSaveDate(Date saveDate) { |
| this.saveDate = saveDate; |
| } |
| private int ocorrenciasGetAdulteradoSet; |
| public int getOcorrenciasGetAdulteradoSet() { |
| return 3000; |
| } |
| public void setOcorrenciasGetAdulteradoSet(int ocorrenciasGetAdulteradoSet) { |
| this.ocorrenciasGetAdulteradoSet = ocorrenciasGetAdulteradoSet; |
| } |
| private int ocorrenciasGetSetNormal; |
| private int ocorrenciasComGetSemSetUsaMetodoNaoTemSetNaoCopia; |
| private int ocorrenciasSemGetNemSetUsaFieldNaoCopiaPrivados; |
| private int ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet; |
| private boolean valorDevolvidoTrue; |
| private boolean valorDevolvidoFalse; |
| public boolean isValorDevolvidoTrue() { |
| return valorDevolvidoTrue; |
| } |
| public boolean isValorDevolvidoFalse() { |
| return valorDevolvidoFalse; |
| } |
| public int getOcorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet() { |
| return ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet; |
| } |
| public void setOcorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet(int ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet) { |
| this.ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet = 100; |
| } |
| public int getOcorrenciasGetSetNormal() |
| { |
| return ocorrenciasGetSetNormal; |
| } |
| public void setOcorrenciasGetSetNormal(int o) |
| { |
| ocorrenciasGetSetNormal = o; |
| } |
| public int getOcorrenciasComGetSemSetUsaMetodoNaoTemSetNaoCopia() { |
| return ocorrenciasComGetSemSetUsaMetodoNaoTemSetNaoCopia; |
| } |
| private int campoOcultoSemGetNemSet; |
| private int campoOcultoSemGetNemSetNemComOutroNome; |
| public int getCampoInvisivel() { |
| return campoOcultoSemGetNemSet; |
| } |
| public void setCampoInvisivel(int campoInvisivel) { |
| this.campoOcultoSemGetNemSet = campoInvisivel; |
| } |
| public void testPriority() throws JSONException { |
| Genson genson = new GensonBuilder() |
| .include("ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet") |
| .include("ocorrenciasGetAdulteradoSet") |
| .create(); |
| TestFieldsAndMethodsTogether t = new TestFieldsAndMethodsTogether(); |
| t.ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet=1000; |
| t.ocorrenciasGetSetNormal = 10; |
| t.ocorrenciasComGetSemSetUsaMetodoNaoTemSetNaoCopia = 20; |
| t.ocorrenciasSemGetNemSetUsaFieldNaoCopiaPrivados = 30; |
| t.valorDevolvidoTrue = true; |
| t.valorDevolvidoFalse = false; |
| t.ocorrenciasGetAdulteradoSet = 1;//tem o get adulterado para devolver 3000 |
| String json = genson.serialize(t); |
| JSONObject jsonParsed = new JSONObject(json); |
| int valor = jsonParsed.getInt("ocorrenciasGetAdulteradoSet"); |
| //fica com o valor do set adulterado |
| assertEquals(valor,3000); |
| TestFieldsAndMethodsTogether t2 = genson.deserialize(json,TestFieldsAndMethodsTogether.class); |
| assertTrue(t2.ocorrenciasGetSetNormal == t.ocorrenciasGetSetNormal); |
| assertTrue(t2.ocorrenciasComGetSemSetUsaMetodoNaoTemSetNaoCopia == 0); |
| assertTrue(t2.ocorrenciasSemGetNemSetUsaFieldNaoCopiaPrivados == 0); |
| //METODO TEM PRIORIDADE |
| assertTrue(t2.ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet == 100); |
| Boolean lidoTrue = jsonParsed.getBoolean("valorDevolvidoTrue"); |
| Boolean lidoFalse = jsonParsed.getBoolean("valorDevolvidoFalse"); |
| assertTrue(lidoTrue); |
| assertFalse(lidoFalse); |
| } |
| public void testFields1() throws JSONException { |
| Genson genson = new GensonBuilder() |
| .useMethods(false) |
| //.exclude(Object.class) resulta no mesmo porque os campos são privados |
| // logo estao automaticamente excluidos e' necessario incluir um a um |
| .include("ocorrenciasGetSetNormal", TestFieldsAndMethodsTogether.class) |
| .include("ocorrenciasComGetSemSetUsaMetodoNaoTemSetNaoCopia",TestFieldsAndMethodsTogether.class) |
| .include("ocorrenciasSemGetNemSetUsaFieldNaoCopiaPrivados",TestFieldsAndMethodsTogether.class) |
| .include("valorDevolvidoTrue",TestFieldsAndMethodsTogether.class) |
| .include("valorDevolvidoFalse",TestFieldsAndMethodsTogether.class) |
| .include("ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet",TestFieldsAndMethodsTogether.class) |
| .include("campoInvisivel",TestFieldsAndMethodsTogether.class) |
| .create(); |
| TestFieldsAndMethodsTogether t = new TestFieldsAndMethodsTogether(); |
| t.ocorrenciasGetSetNormal = 10; |
| t.ocorrenciasComGetSemSetUsaMetodoNaoTemSetNaoCopia = 20; |
| t.ocorrenciasSemGetNemSetUsaFieldNaoCopiaPrivados = 30; |
| t.valorDevolvidoTrue = true; |
| t.valorDevolvidoFalse = false; |
| t.ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet = 200; |
| t.campoOcultoSemGetNemSet = 400; |
| String json = genson.serialize(t); |
| JSONObject jsonParsed = new JSONObject(json); |
| TestFieldsAndMethodsTogether t2 = genson.deserialize(json,TestFieldsAndMethodsTogether.class); |
| assertTrue(t2.ocorrenciasGetSetNormal == t.ocorrenciasGetSetNormal); |
| //Neste caso como foi deliberadamente declarado o campo o sistema usa ou o metodo ou o campo para fazer a alteração |
| assertTrue(t2.ocorrenciasComGetSemSetUsaMetodoNaoTemSetNaoCopia == 20); |
| //Neste caso variaveis explicitamente declaradas o sistema deve copia-las |
| assertTrue(t2.ocorrenciasSemGetNemSetUsaFieldNaoCopiaPrivados == 30); |
| //NEste caso apesar do Set estar a colocar 100 vai usar o valor do campo privado |
| assertTrue(t2.ocorrenciasGetNormalSetUsaValorDiferenteFicaComoDoSet == 200); |
| Boolean lidoTrue = jsonParsed.getBoolean("valorDevolvidoTrue"); |
| Boolean lidoFalse = jsonParsed.getBoolean("valorDevolvidoFalse"); |
| //Os campos mesmo que tenham metodos e esses metodos sejam declarados |
| //No include do Genson, o include serve apenas para Campos e não para |
| //metodos, portanto o campo não é copiado se o use metodos estiver a false |
| //cs campos apenas são copiados se publicos ou incluidos especificamente |
| assertFalse(t2.campoOcultoSemGetNemSet == 400); |
| assertTrue(lidoTrue); |
| assertFalse(lidoFalse); |
| } |
| public void testFields() throws JSONException { |
| Genson genson = new GensonBuilder() |
| .useMethods(true) //O metodo do campoInvisivel que afeta este campo vai preenche-lo |
| .useFields(false) |
| .include("campoOcultoSemGetNemSetNemComOutroNome",TestFieldsAndMethodsTogether.class) |
| .create(); |
| TestFieldsAndMethodsTogether t = new TestFieldsAndMethodsTogether(); |
| t.campoOcultoSemGetNemSet = 400; |
| t.campoOcultoSemGetNemSetNemComOutroNome = 100; |
| String json = genson.serialize(t); |
| JSONObject jsonParsed = new JSONObject(json); |
| TestFieldsAndMethodsTogether t2 = genson.deserialize(json,TestFieldsAndMethodsTogether.class); |
| //Tem um metodo que usa o valor e o acerta |
| assertTrue(t2.campoOcultoSemGetNemSet == 400); |
| //Campos nunca são copiados com o Fields = false logo o valor não passa o assert e' false |
| assertTrue(t2.campoOcultoSemGetNemSetNemComOutroNome != 100); |
| } |
| public void testFields1Herancas() throws JSONException { |
| Genson genson = new GensonBuilder() |
| .useMethods(false) |
| .useClassMetadata(true) |
| .useRuntimeType(true) |
| //.exclude(Object.class) resulta no mesmo porque os campos são privados |
| // logo estao automaticamente excluidos e' necessario incluir um a um |
| .include("ocorrenciasGetSetNormal", TestFieldsAndMethodsChild.class) |
| .create(); |
| TestFieldsAndMethodsChild t = new TestFieldsAndMethodsChild(); |
| t.setOcorrenciasGetSetNormal(10); |
| String json = genson.serialize(t); |
| JSONObject jsonParsed = new JSONObject(json); |
| TestFieldsAndMethodsTogether t2 = genson.deserialize(json,TestFieldsAndMethodsTogether.class); |
| assertTrue(t2.getOcorrenciasGetSetNormal() == t.getOcorrenciasGetSetNormal()); |
| genson = new GensonBuilder() |
| .useMethods(false) |
| .include("ocorrenciasGetSetNormal", TestFieldsAndMethodsTogether.class) |
| .create(); |
| t = new TestFieldsAndMethodsChild(); |
| t.setOcorrenciasGetSetNormal(10); |
| json = genson.serialize(t); |
| jsonParsed = new JSONObject(json); |
| t2 = genson.deserialize(json,TestFieldsAndMethodsTogether.class); |
| assertTrue(t2.getOcorrenciasGetSetNormal() == t.getOcorrenciasGetSetNormal()); |
| } |
| public void testFieldsDates() throws JSONException { |
| Genson genson = new GensonBuilder() |
| .useFields(true) |
| .useMethods(false) |
| .exclude("saveDate",TestFieldsAndMethodsTogether.class) |
| .include("dateStr", TestFieldsAndMethodsTogether.class) |
| .create(); |
| TestFieldsAndMethodsChild t = new TestFieldsAndMethodsChild(); |
| t.setSaveDate(new Date()); |
| String json = genson.serialize(t); |
| TestFieldsAndMethodsChild t2 = genson.deserialize(json,TestFieldsAndMethodsChild.class); |
| //Tem um metodo que usa o valor e o acerta |
| assertEquals(t2.getDateStr(),t.getDateStr()); |
| } |
| public void testMetodosIncludesEdates() throws JSONException { |
| Genson genson = new GensonBuilder() |
| .exclude(Object.class) |
| .useFields(false) |
| .useMethods(true) |
| .exclude("ocorrenciasGetSetNormal",TestFieldsAndMethodsTogether.class) |
| //VAR inexistente apenas existe o metodo |
| .include("dateStr2",TestFieldsAndMethodsChild.class) |
| .create(); |
| TestFieldsAndMethodsChild t = new TestFieldsAndMethodsChild(); |
| t.setSaveDate(new Date()); |
| String json = genson.serialize(t); |
| TestFieldsAndMethodsChild t2 = genson.deserialize(json,TestFieldsAndMethodsChild.class); |
| //Um metodo pode ser excluido, nao pode é ser incluido |
| assertTrue(t2.getOcorrenciasGetSetNormal() == 0); |
| //Tem um metodo que usa o valor e o acerta |
| assertEquals(t2.getDateStr2(),t.getDateStr2()); |
| assertEquals(t2.getSaveDate().getYear(),t.getSaveDate().getYear()); |
| assertEquals(t2.getSaveDate().getMonth(),t.getSaveDate().getMonth()); |
| assertEquals(t2.getSaveDate().getDay(),t.getSaveDate().getDay()); |
| } |
| } |
| /branches/v3/impl/src/java/pt/estgp/estgweb/domain/test/genson/TestFieldsAndMethodsChild.java |
|---|
| New file |
| 0,0 → 1,41 |
| package pt.estgp.estgweb.domain.test.genson; |
| import pt.estgp.estgweb.web.utils.DatesUtils; |
| import java.util.Date; |
| /** |
| * Created by jorgemachado on 19/06/17. |
| */ |
| public class TestFieldsAndMethodsChild extends TestFieldsAndMethodsTogether |
| { |
| private String dateStr; |
| @Override |
| public void setSaveDate(Date saveDate) { |
| super.setSaveDate(saveDate); |
| dateStr = DatesUtils.getStringFromDate(saveDate); |
| } |
| public String getDateStr() |
| { |
| return dateStr; |
| } |
| public void setDateStr(String dateStr) |
| { |
| super.setSaveDate(DatesUtils.getDateFromString(dateStr)); |
| this.dateStr = dateStr; |
| } |
| public String getDateStr2() { |
| return DatesUtils.getStringFromDate(getSaveDate()); |
| } |
| public void setDateStr2(String dateStr2) { |
| super.setSaveDate(DatesUtils.getDateFromString(dateStr2)); |
| } |
| } |
| /branches/v3/impl/src/java/pt/estgp/estgweb/domain/test/genson/NotasGensonProblemasEFeatures |
|---|
| 91,6 → 91,41 |
| Mesmo que seja incluida uma classe ele não inclui os metodos da classe |
| inclui sim gets que devolvam essa classe |
| Usar a primitiva useMethods(false) exclui todos os métodos, |
| os campos serão todos usados mas se estiverem privados não são copiados |
| mas se depois incluirmos os nomes dos campos mesmo que privados desejados |
| ( neste caso não importa se é ou nao na classe certa as heranças nao afetam a classe onde queremos ver o campo) |
| esses campos |
| .include("ocorrenciasGetSetNormal", TestFieldsAndMethodsTogether.class) |
| .include("ocorrenciasGetSetNormal", TestFieldsAndMethodsChild.class) |
| é igual |
| included são usados mas não outros, apenas os publicos os incluidos |
| s campos mesmo que tenham metodos e esses metodos sejam declarados |
| //No include do Genson, o include serve apenas para Campos e não para |
| //metodos, portanto o campo não é copiado se o use metodos estiver a false |
| //os campos apenas são copiados se publicos ou incluidos especificamente |
| Um metodo TEM PRIORIDADE EM RELACAO AO CAMPO |
| Mesmo que o campo seja incluido num include o metodo sobrepõe-se quer o GET quer o SET |
| e desde que o useMethods esteja a true, O CAMPO E COPIADO PRIMEIRO E O SET E FEITO DEPOIS |
| METODOS EXCLUIDO |
| Se usarmos metodos e nao campos e excluirmos um metodo, FUNCIONA |
| ou seja os includes apenas servem para campos |
| mas os excludes aplicam-se a geters e setters |
| Poderá funcionar também |
| ############PROCEDIMENTO ACONSELHADO########################################### |
| Se excluirmos o Object.cautomaticamente excluimos todo so Metodos |
| mesmo os simples, os Metodos podem ser incluidos e assim só ja temos os |
| metodos que queremos e não outros. Classe por classe. |
| Ou seja o include sempre funciona para metodos mas temos de os ter ligados |
| e com o Object Excluido para depois adiconar os metodos que queremos |
| # VER ESTE METODO |
| public void testMetodosIncludesEdates() throws JSONException { |
| NOTA HERANCAS METODOS |
| Os metodos a incluir devem ser incluidos na classe que os comporta e não nas |
| classes descendentes, desse modo não funcionam |
| 110,7 → 145,18 |
| um formato de texto que depois não se consegue desserializar |
| Não usar include(Date.class) |
| nem include("updateDate") |
| isto apenas funciona com o seMethods a true |
| Se quisermos proteger os metodos e coloca-los a false necessitamos |
| de ter um campo auxiliar numa bubclasse e altera-lo quando é feito o setUpdateDate |
| na de cima fazendo override do campo |
| Para desserializar esse auxiliar para o verdadeiro, como os metodos não estão a ser |
| chamados pelo GENSON temos sempre de fazer a passagem à mão para o campo final |
| Existe uma forma melhorada de proteger os metodos veja o ponto acima |
| onde diz ###PROCEDIMENTO ACONSELHADO#### |
| NORMAS DE UTILIZACAO DO GENSON |
| Usar sempre as seguintes diretivas |
| 128,7 → 174,11 |
| TODO |
| VERIFCAR PLANOS DE ESTUDOS EM PARTICULAR OS ECTS eCTS eCts |
| VERIFICAR INTERFACES DO REPOSITORIO JA ESTA BEM MAS NAO ESTA NORMALIZADO |
| //VERIFICADO USA APENAS CAMPOS E OS TESTES ESTAO VALIDADOS FALTA TESTAR NAS ATRIBUICOES |
| VERIFICAR QUESTIONARIOS QUESTÃO DAS TIPOLOGIAS |
| //VERIFICADO |
| VERIFICAR IMPORTACOES QUESTÃO DAS TIPOLOGIAS |
| Verificar como são serializadas as ocorrencias nas tipologias porque não precisam de ser serializadas |