/**
   * @param list
   * @param identidad
   * @param rgia
   * @param idPeticion
   * @throws Exception
   */
  private void almacenarConsultaJugadoresOperador(
      List list, boolean identidad, boolean rgia, int idPeticion) {
    log.debug("<--------Inicio almacenar consulta jugadores con IdPeticion--------> ");
    log.debug("IdPeticion: " + idPeticion);

    if (jugadores != null) {
      for (Jugador jugador : jugadores) {
        String dni = jugador.getDni();
        StringBuffer buf = new StringBuffer();
        if (!ValidadorNIF.isNifNie(jugador.getDni())) {
          if (jugador.getDni().length() > 9) dni = jugador.getDni().substring(0, 9);
          if (dni == null || dni.trim().isEmpty()) return;
        }
        if (identidad && rgia) {
          log.debug("Almacenar jugador de consulta Verificar Jugadores");
          String res_rgiaj = null;
          String res_identidad = null;
          boolean validado = true;
          int indicador = 1;
          if (operador.getModeEnabled() == Constantes.OP_HABILITADO_PRU) indicador = 4;
          if (!ValidadorJugador.todosCaracteresAlfanumericos(jugador)) validado = false;
          for (Iterator<ResultadoJugador> iterRes = list.iterator(); iterRes.hasNext(); ) {
            ResultadoJugador resJugador = iterRes.next();
            if (resJugador.getDni().equalsIgnoreCase(jugador.getDni())) {
              res_rgiaj = resJugador.getResultadoRGIAJ().getCodigo();
              res_identidad = resJugador.getResultadoIdentidad().getCodigo();
              if (res_identidad.equals(CodigosVerificacion.COD_IDENTIDAD_CORRECTA_CACHE))
                resJugador
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_IDENTIDAD_CORRECTA);
              if (res_identidad.equals(CodigosVerificacion.COD_IDENTIDAD_INCORRECTA_CACHE))
                resJugador
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_IDENTIDAD_INCORRECTA);
              if (res_identidad.equals(CodigosVerificacion.COD_IDENTIDAD_CORRECTA_TEST))
                resJugador
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_IDENTIDAD_CORRECTA);
              if (res_identidad.equals(CodigosVerificacion.COD_IDENTIDAD_INCORRECTA_TEST))
                resJugador
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_IDENTIDAD_INCORRECTA);
              if (res_identidad.equals(CodigosVerificacion.COD_NO_VERIFICACION_IDENTIDAD_TEST))
                resJugador
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_NO_VERIFICACION_IDENTIDAD);

              if (res_rgiaj != null && res_rgiaj.contains("TEST")) {
                res_rgiaj = res_rgiaj.substring(0, 6);
                resJugador.getResultadoRGIAJ().setCodigo(res_rgiaj);
                indicador = 4;
              }
              //							if (resJugador.getResultadoRGIAJ() != null
              //									&& resJugador.getResultadoRGIAJ().getCodigo() == "4")
              //								indicador = 4;

              break;
            }
          }

          gestionJugadoresService.almacenarConsultaJugador(
              operador,
              dni,
              jugador.getNombre(),
              jugador.getApellido1(),
              jugador.getApellido2(),
              jugador.getFechaNacimiento(),
              indicador,
              indicador,
              res_rgiaj,
              res_identidad,
              idPeticion,
              validado,
              jugador.getNumSoporte());
        } else if (identidad) {
          log.debug("Almacenar jugador de consulta Verificar Identidad");

          String res_identidad = null;
          boolean validado = true;
          int indicador = 1;
          if (operador.getModeEnabled() == Constantes.OP_HABILITADO_PRU) indicador = 4;
          if (!ValidadorJugador.todosCaracteresAlfanumericos(jugador)) validado = false;
          for (Iterator<ResultadoIdentidad> iterRes = list.iterator(); iterRes.hasNext(); ) {
            ResultadoIdentidad resIdentidad = iterRes.next();
            if (resIdentidad.getDni().equalsIgnoreCase(jugador.getDni())) {
              res_identidad = resIdentidad.getResultadoIdentidad().getCodigo();

              if (res_identidad.equals(CodigosVerificacion.COD_IDENTIDAD_CORRECTA_CACHE))
                resIdentidad
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_IDENTIDAD_CORRECTA);

              if (res_identidad.equals(CodigosVerificacion.COD_IDENTIDAD_INCORRECTA_CACHE))
                resIdentidad
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_IDENTIDAD_INCORRECTA);

              if (res_identidad.equals(CodigosVerificacion.COD_IDENTIDAD_CORRECTA_TEST)) {
                indicador = 4;
                resIdentidad
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_IDENTIDAD_CORRECTA);
              }

              if (res_identidad.equals(CodigosVerificacion.COD_IDENTIDAD_INCORRECTA_TEST)) {
                indicador = 4;
                resIdentidad
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_IDENTIDAD_INCORRECTA);
              }
              if (res_identidad.equals(CodigosVerificacion.COD_NO_VERIFICACION_IDENTIDAD_TEST)) {
                indicador = 4;
                resIdentidad
                    .getResultadoIdentidad()
                    .setCodigo(CodigosVerificacion.COD_NO_VERIFICACION_IDENTIDAD);
              }

              break;
            }
          }
          gestionJugadoresService.almacenarConsultaJugador(
              operador,
              dni,
              jugador.getNombre(),
              jugador.getApellido1(),
              jugador.getApellido2(),
              jugador.getFechaNacimiento(),
              indicador,
              0,
              null,
              res_identidad,
              idPeticion,
              validado,
              jugador.getNumSoporte());
        } else if (rgia) {
          log.debug("Almacenar jugador de consulta Verificar RGIAJ");

          String res_rgiaj = null;
          int indicador = 1;
          if (operador.getModeEnabled() == Constantes.OP_HABILITADO_PRU) indicador = 4;
          for (ResultadoRGIAJ resRGIAJ : (ArrayList<ResultadoRGIAJ>) list) {
            if (resRGIAJ.getDni().equalsIgnoreCase(jugador.getDni())) {
              res_rgiaj = resRGIAJ.getResultadoRGIAJ().getCodigo();
              if (res_rgiaj != null && res_rgiaj.contains("TEST")) {
                res_rgiaj = res_rgiaj.substring(0, 6);
                resRGIAJ.getResultadoRGIAJ().setCodigo(res_rgiaj);
                indicador = 4;
              }
              break;
            }
          }
          gestionJugadoresService.almacenarConsultaJugador(
              operador,
              dni,
              jugador.getNombre(),
              jugador.getApellido1(),
              jugador.getApellido2(),
              jugador.getFechaNacimiento(),
              0,
              indicador,
              res_rgiaj,
              null,
              idPeticion,
              true,
              jugador.getNumSoporte());
        }
      }
    }
  }
  /**
   * Validaci�n del formato de DNI-NIE, Nombre, apellidos y Fecha Nacimiento. Validaci�n de los
   * jugadores (SVDI o Pruebas) seg�n el estado del Operador
   *
   * @return
   * @throws VerificarIdentidadFault_Exception
   */
  public List<ResultadoIdentidad> verificarIdentidad() throws VerificarIdentidadFault_Exception {
    List<ResultadoIdentidad> listaResultado = new ArrayList<ResultadoIdentidad>();
    List<ResultadoIdentidad> listaErrores = new ArrayList<ResultadoIdentidad>();
    List<ResultadoIdentidad> listaPruebas = new ArrayList<ResultadoIdentidad>();
    ResultadoIdentidad resIdentidad = null;

    log.debug("Verificar Identidad: comienzo de la verificacion");

    ValidadorJugador.setVerificacionDao(this.verificacionDao);

    for (Jugador jugador : jugadores) {
      boolean hayError = false;
      boolean hayPruebas = false;

      // Formatear Datos
      ValidadorJugador.formateaDatosJugador(jugador);

      // Valida los datos del jugador
      ResultadoType validation = ValidadorJugador.validarJugador(jugador);
      if (validation != null
          && CodigosVerificacion.COD_FORMATO_INCORRECTO.equals(validation.getCodigo())) {
        log.debug("Error Validando Jugador: " + validation.getDescripcion());
        listaErrores.add(this.generarResultadoIdentidadInvalido(jugador, validation));
        hayError = true;
      } else if (validation != null
          && CodigosVerificacion.COD_CARACTERES_INVALIDOS.equals(validation.getCodigo())) {
        log.debug("Error Validando Jugador: " + validation.getDescripcion());
        listaErrores.add(this.generarResultadoIdentidadInvalido(jugador, validation));
        hayError = true;
      } else if (validation != null
          && CodigosVerificacion.COD_FALTA_CAMPO.equals(validation.getCodigo())) {
        log.debug("Falta campo en el nombre o apellidos: " + validation.getDescripcion());
        listaErrores.add(this.generarResultadoIdentidadInvalido(jugador, validation));
        hayError = true;
      } else if (validation != null
          && CodigosVerificacion.COD_FECHA_NACIMINENTO.equals(validation.getCodigo())) {
        log.debug(
            "Fecha de nacimiento del Jugador es inválida o anterior a 1900: "
                + validation.getDescripcion());
        listaErrores.add(this.generarResultadoIdentidadInvalido(jugador, validation));
        hayError = true;
      } else if (validation != null
          && CodigosVerificacion.COD_NUM_SOPORTE.equals(validation.getCodigo())) {
        log.debug("Error de Formato en el Numero de Soporte: " + validation.getDescripcion());
        listaErrores.add(this.generarResultadoIdentidadInvalido(jugador, validation));
        hayError = true;
      } else if (validation != null
          && CodigosVerificacion.COD_NUM_SOPORTE_NIF.equals(validation.getCodigo())) {
        log.debug("Error de Numero de Soporte: " + validation.getDescripcion());
        listaErrores.add(this.generarResultadoIdentidadInvalido(jugador, validation));
        hayError = true;
      }

      // Si el operador utiliza datos de prueba o datos de prueba y reales
      // se comprueban los usuarios en la BD
      if (!hayError
          && ((operador.getModeEnabled() == Constantes.OP_HABILITADO_PRU)
              || (operador.getModeEnabled() == Constantes.OP_HABILITADO_PRU_PRO))) {

        ResultadoIdentidad resJugador = null;

        log.debug("Operador permite usuarios de prueba (modo: " + operador.getModeEnabled() + ")");
        try {
          resJugador =
              this.getJugadoresTestService().obtenerResultadoIdentidadTestWS(operador, jugador);
          if (resJugador != null) {
            log.debug("Es usuario de prueba: " + jugador.getDni());
            listaPruebas.add(resJugador);
            hayPruebas = true;
          }
        } catch (Exception ex) {
          log.error("Error llamada servicio : " + ex);
          VerificarIdentidadFault fault = new VerificarIdentidadFault();
          fault.setVerificarIdentidadFault(CodigosVerificacion.ERROR_INTERNO);
          throw new VerificarIdentidadFault_Exception(
              CodigosVerificacion.DESC_ERROR_INTERNO, fault);
        }
      }

      if (!hayError && !hayPruebas && (operador.getModeEnabled() == Constantes.OP_HABILITADO_PRU)) {
        // El operador es de pruebas pero el usuario es de produccion se da como invalido
        listaPruebas.add(
            this.generarResultadoIdentidadInvalido(
                jugador,
                new ResultadoType(
                    CodigosVerificacion.COD_IDENTIDAD_INCORRECTA_TEST,
                    CodigosVerificacion.DESC_IDENTIDAD_INCORRECTA)));
        hayPruebas = true;
      }

      resIdentidad = new ResultadoIdentidad();

      // Si el jugador no dio error en las comprobaciones y no es de
      // prueba se verifica su identidad
      if (!hayError && !hayPruebas) {

        log.debug("Es usuario real: " + jugador.getDni());
        // S�lo buscamos en cach� si no se cumple que est� activado el
        // debug y el DNI est� en la tabla de no cachear
        boolean debugActived =
            this.getVerificacionDao()
                .getValorPropiedad(Constantes.PROP_MODO_DEBUG_IDENTIDAD)
                .equals("true");
        if (!debugActived
            || (debugActived && this.getGestionJugadoresService().esCacheable(jugador.getDni()))) {
          log.debug("Se busca en cach\u00E9");
          // Buscar primero en la cach�
          String codResultadoBusquedaCache = null;

          try {
            codResultadoBusquedaCache =
                this.getGestionJugadoresService()
                    .identidadJugadorCache(
                        jugador.getDni(),
                        jugador.getFechaNacimiento(),
                        jugador.getNombre(),
                        jugador.getApellido1(),
                        jugador.getApellido2(),
                        jugador.getNumSoporte());
          } catch (Exception e) {
            log.error("Error verificando Identidad " + e.getMessage(), e);
            VerificarIdentidadFault fault = new VerificarIdentidadFault();
            fault.setVerificarIdentidadFault(CodigosVerificacion.ERROR_INTERNO);
            throw new VerificarIdentidadFault_Exception(
                CodigosVerificacion.DESC_ERROR_INTERNO, fault);
          }

          // Si existe en cach� se devuelve el valor
          if (codResultadoBusquedaCache != null) {
            log.debug("Est\u00E1 en cach\u00E9");
            resIdentidad.setDni(jugador.getDni());
            resIdentidad.setResultadoIdentidad(new ResultadoType());
            resIdentidad.getResultadoIdentidad().setCodigo(codResultadoBusquedaCache);
            resIdentidad
                .getResultadoIdentidad()
                .setDescripcion(CodigosVerificacion.getDescripcion(codResultadoBusquedaCache));

            // Si no existe en cach� se busca en el servicio de la
            // polic�a
          } else {
            log.debug("No est\u00E1 en cach\u00E9, se consulta al servicio de la policia");
            CodigoEstadoSCSP codigoResultado = null;
            try {
              codigoResultado =
                  this.getClienteSCSPService()
                      .verificarIdentidad(
                          jugador.getDni(),
                          jugador.getNumSoporte(),
                          jugador.getNombre(),
                          jugador.getApellido1(),
                          jugador.getApellido2(),
                          jugador.getFechaNacimiento());
            } catch (Exception e) {
              log.error("Error verificando Identidad con cliente SCP " + e.getMessage(), e);
              codigoResultado = new CodigoEstadoSCSP();
              codigoResultado.setCodigo(CodigosVerificacion.COD_NO_VERIFICACION_IDENTIDAD);
              codigoResultado.setDescripcion(CodigosVerificacion.DESC_NO_VERIFICACION_IDENTIDAD);
              //							throw new VerificarIdentidadFault_Exception(e.getMessage(),e);
            }
            resIdentidad.setDni(jugador.getDni());
            resIdentidad.setResultadoIdentidad(new ResultadoType());
            resIdentidad.getResultadoIdentidad().setCodigo(codigoResultado.getCodigo());
            resIdentidad.getResultadoIdentidad().setDescripcion(codigoResultado.getDescripcion());
          }

        } else {
          log.debug("No se debe consultar cach\u00E9, se consulta al servicio de la policia");

          // Se comprueba la identidad llamando al servicio
          CodigoEstadoSCSP codigoResultado = null;
          try {
            codigoResultado =
                this.getClienteSCSPService()
                    .verificarIdentidad(
                        jugador.getDni(),
                        jugador.getNumSoporte(),
                        jugador.getNombre(),
                        jugador.getApellido1(),
                        jugador.getApellido2(),
                        jugador.getFechaNacimiento());
          } catch (Exception e) {
            // TODO Auto-generated catch block
            log.error("Error verificando Identidad " + e.getMessage(), e);
            codigoResultado = new CodigoEstadoSCSP();
            codigoResultado.setCodigo(CodigosVerificacion.COD_NO_VERIFICACION_IDENTIDAD);
            codigoResultado.setDescripcion(CodigosVerificacion.DESC_NO_VERIFICACION_IDENTIDAD);
          }
          resIdentidad.setDni(jugador.getDni());
          resIdentidad.setResultadoIdentidad(new ResultadoType());
          resIdentidad.getResultadoIdentidad().setCodigo(codigoResultado.getCodigo());
          resIdentidad.getResultadoIdentidad().setDescripcion(codigoResultado.getDescripcion());
        }

        listaResultado.add(resIdentidad);
      }
    }

    listaResultado.addAll(listaErrores);
    listaResultado.addAll(listaPruebas);

    return listaResultado;
  }