Verify Data

Question

Verify Data

Navigation

#1 by (2 votes)
#2 by (2 votes)

1

I'm blocked and I do not know how to move forward.

I have the following information:

String Equiv1="";
    String Equiv2="";
    String equivalencia1="";

public int probarEquiv1 (){
    Equiv1 =ConversorNou.PrimeraDivisaTXT.getText();
    Equiv2 = ConversorNou.SegundaDivisaTXT.getText();
    equivalencia1 = ConversorNou.EquivalenciaTXT.getText();

And I have to check them one by one.

That is:

1- Verify that Equiv1 is "Dollar", "Euro", "weight" if it is correct to proceed to the next verification.

2- Check Equiv2: Be "dollar", Euro, Weight but do not repeat with Equiv1 (ie if Equiv1 is Dollar then Equiv2 can only be Peso or Euro) If it is correct, it will verify the following.

3-Verify that it is Equivalence that must be: Number greater than 0, and can accept decimals.

What is my problem that I know how to verify them all together but not separately.

In the end if the verification of everything is correct they have to go to RETURN 1 if it is incorrect to RETURN 2 (but if the return 2 option comes out that is incorrect I have to know which part of the verification is incorrect)

The problem I have is that I do not know how to do the checks one by one and have the return show what the wrong data is.

If any of the 3 verifications fails, I have to know 100% of them and show it with the setFocus ()

The part of the return is this:

Button botonDadesEntrades = new Button(Conversor_de_divises, SWT.BORDER);
        botonDadesEntrades.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent e) {
            if (data.probarEquiv1()==1){
                JOptionPane.showMessageDialog(null, "Datos Correctos");


            }else{
                 PrimeraDivisaTXT.setFocus(); // asigno el foco al textfield 
                 PrimeraDivisaTXT.selectAll(); // luego selecciono todo el texto 

                JOptionPane.showMessageDialog(null, "Error has puesto un dato incorrecto "

            }

            }
        });

I need to know how to modify the return part 2 so that it shows what the wrong data is.

Thanks in advance! It involves using the setfocus () setall () to select the wrong one. But I'm blocked .. T_T

thanks!

Edited:

The part to prove Equiv1 that I have done:

if(Equiv1.equalsIgnoreCase("Euro")&& Equiv2.equalsIgnoreCase("Dolar")&& DatosUser.esDecimal1(equivalencia1)){
        return 1;
    }
    else if ( Equiv1.equalsIgnoreCase("Dolar")&& Equiv2.equalsIgnoreCase("Euro")&& DatosUser.isNumeric(equivalencia1)){
    return 1;               
    }
    else if ( Equiv1.equalsIgnoreCase("Euro")&& Equiv2.equalsIgnoreCase("Dolar")&& DatosUser.isNumeric(equivalencia1)){
        return 1;
    }
    else if (Equiv1.equalsIgnoreCase("Dolar")&& Equiv2.equalsIgnoreCase("Euro")&& DatosUser.esDecimal1(equivalencia1)){
        return 1;
    }
    else{
        return 0;
    }

}

     private static boolean isNumeric(String cadena){
            try {
                Integer.parseInt(cadena);
                return true;
            } catch (NumberFormatException nfe){
                return false;
            }}


     public static boolean esDecimal1(String cad)
     {
     boolean hayPunto=false;
     StringBuffer parteEntera = new StringBuffer();
     StringBuffer parteDecimal = new StringBuffer();
     int i=0, posicionDelPunto;

     for( i=0;i<cad.length(); i++ )
     if ( cad.charAt(i) == '.')                          //Detectar si hay un punto decimal en la cadena
     hayPunto=true;
     if(hayPunto)                                            //Si hay punto guardar la posicion donde se encuentra el carater punto
     posicionDelPunto=cad.indexOf('.');                  //(si la cadena tiene varios puntos, detecta donde esta el primero).
     else
     return false;                                       //Si no hay punto; no es decimal

     if( posicionDelPunto == cad.length()-1 || posicionDelPunto== 0)    //Si el punto esta al final o al principio no es un decimal
     return false;

     for( i=0;i<posicionDelPunto; i++ )
     parteEntera.append(cad.charAt(i)) ;                 //Guardar la parte entera en una variable

     for(i = 0; i<parteEntera.length(); i++)
     if( ! Character.isDigit(parteEntera.charAt(i)) )    //Si alguno de los caracteres de la parte entera no son digitos no es decimal
     return false;

     for( i=posicionDelPunto+1;i<cad.length(); i++ )
     parteDecimal.append(cad.charAt(i));                 //Guardar la parte decimal en una variable

     for(i = 0; i<parteDecimal.length(); i++)
     if( ! Character.isDigit(parteDecimal.charAt(i)) )   //Si alguno de los caracteres de la parte decimal no es un digito no es decimal
     return false;                                   //Incluye el caso en el que la cadena tenga dos o mas puntos

     return true;                                            //Si paso todas las pruebas anteriores, la cadena es un Numero decimal
     }


     public boolean esDecimal(String cad)
     {
     try
     {
       Double.parseDouble(cad);
       return true;
     }
     catch(NumberFormatException nfe)
     {
       return false;
     }




    }
}

java

asked by Montse Mkd 10.04.2016 в 04:03

source

2 answers

2

I have attached a code to solve your problem, the validations are in private methods and to form what you call RETURN I have created the Result class that stores the results of validation, you can modify it to your liking:

public class Validador {
  private static final String EURO = "Euro";
  private static final String DOLAR = "Dolar";
  private static final String PESO = "Peso";

  public Resultado procesa(String tipoMoneda1, String tipoMoneda2, String equivalencia) {
    Resultado resultado = new Resultado();
    if (validaTipoMoneda(tipoMoneda1)) {
        if (validaTipoMoneda(tipoMoneda2)) {
            if (!sonMismoTipoMoneda(tipoMoneda1, tipoMoneda2)) {
                try {
                    double equivalenciaConvertida = convierteEquivalencia(equivalencia);
                    resultado.setTipoReturn("RETURN1");
                    resultado.setErrorValidacion("no existen errores");
                } catch (NumberFormatException e2) {
                    resultado.setTipoReturn("RETURN2");
                    resultado.setErrorValidacion("Equivalencia no es convertible a valor numerico");
                    return resultado;
                }
            } else {
                resultado.setTipoReturn("RETURN2");
                resultado.setErrorValidacion("tipo de moneda 1 y tipo de moneda 2 son iguales");
            }
        } else {
            resultado.setTipoReturn("RETURN2");
            resultado.setErrorValidacion("tipo de moneda 2 no valida");
        }
    } else {
        resultado.setTipoReturn("RETURN2");
        resultado.setErrorValidacion("tipo de moneda 1 no valida");
    }
    return resultado;
  }

  private boolean validaTipoMoneda(String tipoMoneda) {
    return tipoMoneda.equalsIgnoreCase(EURO) || tipoMoneda.equalsIgnoreCase(DOLAR)
            || tipoMoneda.equalsIgnoreCase(PESO) ? true : false;
  }

  private boolean sonMismoTipoMoneda(String tipoMoneda1, String tipoMoneda2) {
    return tipoMoneda1.equalsIgnoreCase(tipoMoneda2) ? true : false;
  }

  private double convierteEquivalencia(String equivalencia) {
    return Double.valueOf(equivalencia);
  }

  class Resultado {
    private String tipoReturn;
    private String errorValidacion;

    public String getTipoReturn() {
        return tipoReturn;
    }

    public void setTipoReturn(String tipoReturn) {
        this.tipoReturn = tipoReturn;
    }

    public String getErrorValidacion() {
        return errorValidacion;
    }

    public void setErrorValidacion(String errorValidacion) {
        this.errorValidacion = errorValidacion;
    }

  }

}

Your tests to verify the expected behavior:

public class ValidadorTest {

  @Test
  public void testValida_moneda1_no_valida() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Rupia", "Dolar", "1.23");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN2")));
    assertThat(res.getErrorValidacion(), is(equalTo("tipo de moneda 1 no valida")));
  }

  @Test
  public void testValida_moneda2_no_valida() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Rupia", "1.23");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN2")));
    assertThat(res.getErrorValidacion(), is(equalTo("tipo de moneda 2 no valida")));
  }

  @Test
  public void testValida_monedas_son_iguales() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Dolar", "1.23");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN2")));
    assertThat(res.getErrorValidacion(), is(equalTo("tipo de moneda 1 y tipo de moneda 2 son iguales")));
  }

  @Test
  public void testValida_equivalencia_no_convertible() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Euro", "23#2");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN2")));
    assertThat(res.getErrorValidacion(), is(equalTo("Equivalencia no es convertible a valor numerico")));
  }

  @Test
  public void testValida_ok() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Euro", "1.17");
    assertThat(res.getTipoReturn(), is(equalTo("RETURN1")));
    assertThat(res.getErrorValidacion(), is(equalTo("no existen errores")));
  }

}

I hope it helps you;)

answered by 11.04.2016 в 02:02

How can I avoid opening a User Control? NoSQL Redis Databases with .Net Framework

score 2 · Accepted Answer

I also attach here another way to view the topic, perform the validation of all the attributes you want and generate a list of errors, that is, the validation is always done to all the attributes and then a list of errors is generated and a status of the validation that will only be OK if there is no error, I pass the code to you:

public class Validador {
  private static final String EURO = "Euro";
  private static final String DOLAR = "Dolar";
  private static final String PESO = "Peso";

  public Resultado procesa(String tipoMoneda1, String tipoMoneda2,
        String equivalencia) {
    Resultado resultado = new Resultado();
    if (!validaTipoMoneda(tipoMoneda1)) {
        resultado.setEstado(Resultado.KO);
        resultado.addError("tipo de moneda 1 no valida");
    }
    if (!validaTipoMoneda(tipoMoneda2)) {
        resultado.setEstado(Resultado.KO);
        resultado.addError("tipo de moneda 2 no valida");
    }
    if (sonMismoTipoMoneda(tipoMoneda1, tipoMoneda2)) {
        resultado.setEstado(Resultado.KO);
        resultado.addError("tipo de moneda 1 y tipo de moneda 2 son iguales");
    }
    try {
        double equivalenciaConvertida = convierteEquivalencia(equivalencia);
    } catch (NumberFormatException e2) {
        resultado.setEstado(Resultado.KO);
        resultado.addError("Equivalencia no es convertible a valor numerico");
        return resultado;
    }
    return resultado;
  }

  private boolean validaTipoMoneda(String tipoMoneda) {
    return tipoMoneda.equalsIgnoreCase(EURO)
            || tipoMoneda.equalsIgnoreCase(DOLAR)
            || tipoMoneda.equalsIgnoreCase(PESO) ? true : false;
  }

  private boolean sonMismoTipoMoneda(String tipoMoneda1, String tipoMoneda2) {
    return tipoMoneda1.equalsIgnoreCase(tipoMoneda2) ? true : false;
  }

  private double convierteEquivalencia(String equivalencia) {
    return Double.valueOf(equivalencia);
  }

  class Resultado {
    public static final boolean OK=true;
    public static final boolean KO=false;
    private boolean estado;
    private List<String> errores;

    public Resultado() {
        this.estado=OK;
        this.errores=new ArrayList<String>();
    }

    public boolean isEstado() {
        return estado;
    }

    public void setEstado(boolean estado) {
        this.estado = estado;
    }

    public List<String> getErrores() {
        return errores;
    }

    public void setErrores(List<String> errores) {
        this.errores = errores;
    }

    public void addError(String error) {
        errores.add(error);
    }

  }

}

Your tests to verify correct behavior:

public class ValidadorTest {

  @Test
  public void testValida_moneda1_no_valida() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Rupia", "Dolar", "1.23");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(1));
    assertThat(res.getErrores().get(0),is(equalTo("tipo de moneda 1 no valida")));
  }

  @Test
  public void testValida_moneda2_no_valida() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Rupia", "1.23");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(1));
    assertThat(res.getErrores().get(0),is(equalTo("tipo de moneda 2 no valida")));
  }

  @Test
  public void testValida_monedas_son_iguales() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Dolar", "1.23");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(1));
    assertThat(res.getErrores().get(0),is(equalTo("tipo de moneda 1 y tipo de moneda 2 son iguales")));
  }

  @Test
  public void testValida_equivalencia_no_convertible() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Euro", "23#2");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(1));
    assertThat(res.getErrores().get(0),is(equalTo("Equivalencia no es convertible a valor numerico")));
  }

  @Test
  public void testValida_ok() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Dolar", "Euro", "1.17");
    assertThat(res.isEstado(), is(equalTo(Resultado.OK)));
    assertThat(res.getErrores().size(),is(0));
  }

  @Test
  public void testValida_listaErrores() {
    Validador validador = new Validador();
    Resultado res = validador.procesa("Rupia", "Rupia", "23#4");
    assertThat(res.isEstado(), is(equalTo(Resultado.KO)));
    assertThat(res.getErrores().size(),is(4));
    assertThat(res.getErrores().get(0),is(equalTo("tipo de moneda 1 no valida")));
    assertThat(res.getErrores().get(1),is(equalTo("tipo de moneda 2 no valida")));
    assertThat(res.getErrores().get(2),is(equalTo("tipo de moneda 1 y tipo de moneda 2 son iguales")));
    assertThat(res.getErrores().get(3),is(equalTo("Equivalencia no es convertible a valor numerico")));
  }

}