Example #1
0
 @Override
 public Object getFieldValue(JRField jrField) throws JRException {
   Object valor = null;
   if (tabla != null) {
     for (int i = 0; i < tabla.getTotalColumnas(); i++) {
       if (tabla.getColumnas()[i].getNombre().equalsIgnoreCase(jrField.getName())) {
         valor = tabla.getValor(indice, tabla.getColumnas()[i].getNombre());
         break;
       }
     }
   } else if (tablaGenerica != null) {
     for (int i = 0; i < tablaGenerica.getTotalColumnas(); i++) {
       if (tablaGenerica.getColumnas()[i].getNombre().equalsIgnoreCase(jrField.getName())) {
         valor = tablaGenerica.getValor(indice, tablaGenerica.getColumnas()[i].getNombre());
         break;
       }
     }
   } else if (lista != null) {
     for (int i = 0; i < lista.get(indice).getNombreColumna().length; i++) {
       if (lista.get(indice).getNombreColumna()[i].equalsIgnoreCase(jrField.getName())) {
         valor = lista.get(indice).getValor()[i];
         break;
       }
     }
   }
   return valor;
 }
Example #2
0
 /**
  * Consulta si es necesario que el usuario cambie
  *
  * @param ide_usua
  * @return
  */
 public boolean isCambiarClave(String ide_usua) {
   // Si el cambia_clave esta en true
   TablaGenerica tab_usuario =
       utilitario.consultar(
           "SELECT * FROM SIS_USUARIO WHERE IDE_USUA=" + ide_usua + " AND cambia_clave_usua=true");
   return !tab_usuario.isEmpty();
 }
Example #3
0
  /**
   * Busca si el usuario ya se encuentra logeado en una máquina
   *
   * @param ide_usua Clave primaria del usuario
   * @return
   */
  public boolean isUsuarioLogeado(String ide_usua) {
    // Busca si el usuario no tiene una session activa en otra ip
    boolean boo_logeado = false;
    // Busco en auditoria acceso los ingresos q se encuentran activos por
    // fecha,ip,usuario y estado fin de session = false
    TablaGenerica tab_logeo =
        utilitario.consultar(
            "SELECT * FROM SIS_AUDITORIA_ACCESO WHERE IDE_USUA="
                + ide_usua
                + " AND FECHA_AUAC="
                + utilitario.getFormatoFechaSQL(utilitario.getFechaActual())
                + " AND FIN_AUAC=false AND IDE_ACAU="
                + P_SIS_INGRESO_USUARIO);

    if (!tab_logeo.isEmpty()) {
      // Comparo si la ip del cliente con las de la tabla
      String str_ip = utilitario.getIp();
      for (int i = 0; i < tab_logeo.getTotalFilas(); i++) {
        if (!tab_logeo.getValor(i, "IP_AUAC").equalsIgnoreCase(str_ip)) {
          // ya tiene una session en otra ip
          boo_logeado = true;
          break;
        }
      }
    }
    return boo_logeado;
  }
Example #4
0
 public void visualizarRol() {
   if (rolSeleccionado != null) {
     GenerarReporte ger = new GenerarReporte();
     Map parametros = new HashMap();
     try {
       parametros.put("IDE_GEPRO", Long.parseLong(((Object[]) rolSeleccionado)[4] + ""));
     } catch (Exception e) {
     }
     parametros.put("IDE_NRDTN", Long.parseLong(((Object[]) rolSeleccionado)[3] + ""));
     TablaGenerica tab_partida = ser_empleado.getPartida(utilitario.getVariable("IDE_GTEMP"));
     parametros.put("IDE_GEEDP", tab_partida.getValor("IDE_GEEDP"));
     parametros.put("titulo", " BOLETA DE PAGO");
     parametros.put(
         "IDE_NRTIR",
         utilitario.getVariable("p_nrh_trubro_egreso")
             + ","
             + utilitario.getVariable("p_nrh_trubro_ingreso"));
     parametros.put(
         "par_total_recibir",
         Integer.parseInt(utilitario.getVariable("p_nrh_rubro_valor_recibir")));
     parametros.put(
         "par_total_ingresos",
         Integer.parseInt(utilitario.getVariable("p_nrh_rubro_total_ingresos")));
     parametros.put(
         "par_total_egresos",
         Integer.parseInt(utilitario.getVariable("p_nrh_rubro_total_egresos")));
     ger.generar(parametros, "/reportes/rep_rol_de_pagos/rep_n_rol_pagos.jasper");
   }
 }
Example #5
0
  @Override
  public void aceptarReporte() {
    Locale locale = new Locale("es", "ES");

    if (rep_reporte.getReporteSelecionado().equals("Comprobante Pago")) {

      if (rep_reporte.isVisible()) {
        p_parametros = new HashMap();
        rep_reporte.cerrar();
        //		p_parametros.put("IDE_GTEMP",Long.parseLong(tab_anticipo.getValor("IDE_GTEMP")));
        TablaGenerica tab_valor =
            utilitario.consultar(
                ser_Tesoreria.getConsulValorPagoContabilidad(tab_movimiento.getValor("ide_comov")));
        p_parametros.put("titulo", "EMGIRS - EP");
        p_parametros.put("p_contador_general", utilitario.getVariable("p_nombre_contador"));
        p_parametros.put(
            "p_cuota_mensual",
            utilitario.getLetrasDolarNumero(
                utilitario.getFormatoNumero(tab_valor.getValor("valor"), 2)));
        p_parametros.put("p_ide_comov", Integer.parseInt(tab_movimiento.getValor("ide_comov")));

        p_parametros.put("REPORT_LOCALE", locale);
        sef_reporte.setSeleccionFormatoReporte(p_parametros, rep_reporte.getPath());
        sef_reporte.dibujar();

      } else {
        utilitario.agregarMensajeInfo(
            "No se puede continuar",
            "No ha seleccionado ningun registro en la cabecera del anticipo");
      }
    }
  }
Example #6
0
 @PostConstruct
 public void cargarDatos() {
   TablaGenerica tab_partida = ser_empleado.getPartida(utilitario.getVariable("IDE_GTEMP"));
   if (tab_partida != null) {
     lisRolesPago = ser_empleado.getRolesEmpleadoLista(tab_partida.getValor("IDE_GEEDP"));
   }
   strPathReporte =
       utilitario.getURL() + "/reportes/reporte" + utilitario.getVariable("IDE_USUA") + ".pdf";
 }
  public void aceptarImpuesto() {
    System.out.println("entra a metodo aceptar impues");

    if (set_impuesto.isVisible()) {
      if (set_impuesto.getValorSeleccionado() != null) {
        tab_detalle_retencion.insertar();

        if (set_impuesto.getValorSeleccionado().equals(par_impuesto_iva)) {
          tab_detalle_retencion.setValor(
              "base_imponible_teder", tab_adq_factura.getValor("valor_iva_adfac"));
        } else if (set_impuesto.getValorSeleccionado().equals(par_impuesto_renta)) {
          tab_detalle_retencion.setValor(
              "base_imponible_teder", tab_adq_factura.getValor("subtotal_adfac"));
        }
        str_seleccionado = set_impuesto.getValorSeleccionado();
        System.out.println("probando que valor me llega" + str_seleccionado);
        set_retencion
            .getTab_seleccion()
            .setSql(ser_Tesoreria.getImpuesto("true", "0", str_seleccionado));
        set_retencion.getTab_seleccion().ejecutarSql();
        set_retencion.dibujar();
        set_impuesto.cerrar();

      } else {
        utilitario.agregarMensajeInfo("SELECCIONE OPCION", "Seleccione un registro");
      }

    } else if (set_retencion.isVisible()) {
      str_seleccionado = set_retencion.getValorSeleccionado();
      TablaGenerica tab_rentas =
          utilitario.consultar(ser_Tesoreria.getImpuestoCalculo(str_seleccionado));

      double dou_valor_impuesto = 0;
      double dou_porcentaje_calculo = 0;
      double dou_valor_resultado = 0;

      dou_porcentaje_calculo = Double.parseDouble(tab_rentas.getValor("porcentaje_teimp"));
      dou_valor_impuesto =
          Double.parseDouble(tab_detalle_retencion.getValor("base_imponible_teder"));
      dou_valor_resultado = (dou_porcentaje_calculo * dou_valor_impuesto) / 100;

      if (set_retencion.getValorSeleccionado() != null) {

        tab_detalle_retencion.setValor("ide_teimp", str_seleccionado);
        tab_detalle_retencion.setValor("valor_retenido_teder", dou_valor_resultado + "");
        String valorx = tab_detalle_retencion.getSumaColumna("valor_retenido_teder") + "";
        tab_retencion.setValor("total_ret_teret", valorx);
      }

      set_retencion.cerrar();
      utilitario.addUpdateTabla(
          tab_detalle_retencion, "valor_retenido_teder,base_imponible_teder,ide_teimp", "");
      utilitario.addUpdateTabla(tab_retencion, "total_ret_teret", "");
      calcularValorPago();
      utilitario.addUpdateTabla(tab_comprobante, "valor_pago_tecpo,", "");
    }
  }
 public void secuencial() {
   TablaGenerica tabDato =
       aCombustible.getVehiculo(Integer.parseInt(tabTabla.getValor("mve_secuencial")));
   if (!tabDato.isEmpty()) {
     if (tabDato.getValor("placa").equals("0000000")) {
       if (tabTabla.getValor("abastecimiento_fecha") != null
           && tabTabla.getValor("abastecimiento_fecha").toString().isEmpty() == false) {
         if (tabTabla.getValor("abastecimiento_numero") != null
             && tabTabla.getValor("abastecimiento_numero").toString().isEmpty() == false) {
         } else {
           Integer numero =
               Integer.parseInt(
                   aCombustible.listaMax(
                       Integer.parseInt(tabTabla.getValor("abastecimiento_cod_dependencia")),
                       String.valueOf(
                           utilitario.getAnio(tabTabla.getValor("abastecimiento_fecha"))),
                       String.valueOf(
                           utilitario.getMes(tabTabla.getValor("abastecimiento_fecha")))));
           Integer cantidad = 0;
           cantidad = numero + 1;
           tabTabla.setValor("abastecimiento_numero", String.valueOf(cantidad));
           utilitario.addUpdate("tabTabla");
         }
       } else {
         tabTabla.setValor("abastecimiento_numero_vale", null);
         utilitario.addUpdate("tabTabla");
         utilitario.agregarMensaje("Ingresar Fecha de Abastecimiento", "");
       }
     } else {
       if (tabTabla.getValor("abastecimiento_fecha") != null
           && tabTabla.getValor("abastecimiento_fecha").toString().isEmpty() == false) {
         if (tabTabla.getValor("abastecimiento_numero") != null
             && tabTabla.getValor("abastecimiento_numero").toString().isEmpty() == false) {
         } else {
           Integer numero =
               Integer.parseInt(
                   aCombustible.listaMax(
                       Integer.parseInt(tabTabla.getValor("mve_secuencial")),
                       String.valueOf(
                           utilitario.getAnio(tabTabla.getValor("abastecimiento_fecha"))),
                       String.valueOf(
                           utilitario.getMes(tabTabla.getValor("abastecimiento_fecha")))));
           Integer cantidad = 0;
           cantidad = numero + 1;
           tabTabla.setValor("abastecimiento_numero", String.valueOf(cantidad));
           utilitario.addUpdate("tabTabla");
         }
       } else {
         tabTabla.setValor("abastecimiento_numero_vale", null);
         utilitario.addUpdate("tabTabla");
         utilitario.agregarMensaje("Ingresar Fecha de Abastecimiento", "");
       }
     }
   } else {
     utilitario.agregarMensajeError("Valor", "No Se Encuentra Registrado");
   }
 }
Example #9
0
 public String getClaveUsuario(String ide_usua) {
   String str_clave = null;
   // Retorna la clave activa de un usuario
   TablaGenerica tab_clave = getClaveActivaUusario(ide_usua);
   if (tab_clave.isEmpty() == false) {
     str_clave = tab_clave.getValor("CLAVE_USCL");
   }
   return str_clave;
 }
Example #10
0
 /**
  * Busca un campo de la base de datos de la tabla sis_empresa
  *
  * @param campo
  * @return
  */
 public String getCampoEmpresa(String campo) {
   String valor = null;
   TablaGenerica tab_empresa =
       consultar(
           "SELECT IDE_EMPR,"
               + campo
               + " FROM SIS_EMPRESA WHERE IDE_EMPR="
               + getVariable("IDE_EMPR"));
   if (tab_empresa.getTotalFilas() > 0) {
     valor = tab_empresa.getValor(0, campo);
   }
   return valor;
 }
 public void valor() {
   TablaGenerica tabDato =
       aCombustible.getCombustible(Integer.parseInt(tabTabla.getValor("tipo_combustible_id")));
   if (!tabDato.isEmpty()) {
     Double valor;
     valor =
         (Double.parseDouble(tabDato.getValor("tipo_valor_galon"))
             * Double.parseDouble(tabTabla.getValor("abastecimiento_galones")));
     tabTabla.setValor("abastecimiento_total", String.valueOf(Math.rint(valor * 100) / 100));
     utilitario.addUpdate("tabTabla");
   } else {
     utilitario.agregarMensajeError("Valor", "No Se Encuentra Registrado");
   }
 }
Example #12
0
 /**
  * Método que busca el numero maximo de intentos para poder acceder al sistema
  *
  * @return Número entero de intentos permitidos.
  */
 public int getNumeroIntentosAcceso() {
   // Retorna el numero de fallos para el acceso al sistema
   int int_intentos = 3; // valor por defecto
   TablaGenerica tab_intentos = getReglas();
   if (tab_intentos.isEmpty() == false) {
     if (tab_intentos.getValor("intentos_recl") != null) {
       try {
         int_intentos = Integer.parseInt(tab_intentos.getValor("intentos_recl"));
       } catch (Exception e) {
       }
     }
   }
   return int_intentos;
 }
Example #13
0
 /**
  * Busca la longitud mínima para el campo nick del login
  *
  * @return
  */
 public int getLongitudMinimaLogin() {
   // retorna el tamaño maximo para el login de un usuario
   int int_longitud = 0;
   TablaGenerica tab_intentos = getReglas();
   if (tab_intentos.isEmpty() == false) {
     if (tab_intentos.getValor("longitud_login_recl") != null) {
       try {
         int_longitud = Integer.parseInt(tab_intentos.getValor("longitud_login_recl"));
       } catch (Exception e) {
       }
     }
   }
   return int_longitud;
 }
 public void kilometraje() {
   TablaGenerica tabDato =
       aCombustible.getVehiculo(Integer.parseInt(tabTabla.getValor("mve_secuencial")));
   if (!tabDato.isEmpty()) {
     Double valor1 = Double.valueOf(tabDato.getValor("kilometros_actual"));
     Double valor2 = Double.valueOf(tabTabla.getValor("abastecimiento_kilometraje"));
     if (valor2 >= valor1) {
     } else {
       utilitario.agregarMensajeError("Kilometraje", "Por Debajo del Anterior");
     }
   } else {
     utilitario.agregarMensajeError("Registro", "No Se Encuentra Disponible");
   }
 }
  public void aceptarCertificacionPresupuestaria() {
    System.out.println("entra a metodo aceptar cert");

    String str_seleccionado = set_tramite.getValorSeleccionado();
    TablaGenerica tab_tramite = ser_Presupuesto.getTablaGenericaTramite(str_seleccionado);
    if (str_seleccionado != null) {
      tab_comprobante.insertar();
      tab_detalle_movimiento.limpiar();
      tab_detalle_movimiento.setColumnaSuma("haber_codem,debe_codem");
      tab_comprobante.setValor("ide_prtra", tab_tramite.getValor("ide_prtra"));
    }
    set_tramite.cerrar();
    utilitario.addUpdate("tab_comprobante");
  }
Example #16
0
 /**
  * Método que busca si la clave de un usuario a una fecha determinada esta vigente o esta caducada
  *
  * @param ide_usua es la identificador del usuario
  * @param fecha es la fecha a la cual quiero comparar la fecha de caducidad
  * @return true si la clave esta vigente y false si la clave ya caduco
  */
 public boolean isClaveVigente(String ide_usua, String fecha) {
   // Si la clave de un usuario a una fecha determinada esta caducada
   TablaGenerica tab_clave = getClaveActivaUusario(ide_usua);
   if (tab_clave.isEmpty() == false) {
     // Verifica que la clave no haya caducado
     if (tab_clave.getValor("fecha_vence_uscl") != null) {
       if (utilitario.isFechaMayor(
           utilitario.getFecha(fecha),
           utilitario.getFecha(tab_clave.getValor("fecha_vence_uscl")))) {
         return true;
       }
     }
   }
   return false;
 }
 public void actu() {
   TablaGenerica tabDato =
       aCombustible.getVehiculo(Integer.parseInt(tabTabla.getValor("mve_secuencial")));
   if (!tabDato.isEmpty()) {
     if (tabDato.getValor("placa").equals("0000000")) {
     } else {
       aCombustible.set_ActuaKM(
           Integer.parseInt(tabTabla.getValor("mve_secuencial")),
           Integer.parseInt(tabTabla.getValor("abastecimiento_kilometraje")),
           "set kilometros_actual");
     }
   } else {
     utilitario.agregarMensajeError("Valor", "No Se Encuentra Registrado");
   }
 }
  public void aceptarSolicitudCompra() {
    System.out.println("entra a metodo aceptar solicitud");

    String str_seleccionado = set_solicitud.getValorSeleccionado();
    TablaGenerica tab_solicitud = ser_Adquisicion.getTablaGenericaSolicitud(str_seleccionado);
    if (str_seleccionado != null) {
      tab_comprobante.insertar();
      tab_comprobante.setValor("ide_adsoc", str_seleccionado);
      tab_comprobante.setValor("valor_compra_tecpo", tab_solicitud.getValor("total_adfac"));
      tab_comprobante.setValor("valor_iva_tecpo", tab_solicitud.getValor("valor_iva_adfac"));
      tab_comprobante.setValor("ide_prtra", tab_solicitud.getValor("ide_prtra"));
      tab_comprobante.setValor("ide_tepro", tab_solicitud.getValor("ide_tepro"));
    }
    set_solicitud.cerrar();
    utilitario.addUpdate("tab_comprobante");
  }
Example #19
0
 /**
  * Busca el número de días de un periodo de vigencia de claves
  *
  * @param ide_pecl Clave primaria del período de claves
  * @return el numero de dias del periodo de cambio de clave
  */
 public int getDiasPeriodoClave(String ide_pecl) {
   //
   int int_dias = 0;
   if (ide_pecl != null) {
     TablaGenerica tab_periodos =
         utilitario.consultar("SELECT * FROM sis_periodo_clave WHERE ide_pecl=" + ide_pecl);
     if (tab_periodos.isEmpty() == false) {
       if (tab_periodos.getValor("num_dias") != null) {
         try {
           int_dias = Integer.parseInt(tab_periodos.getValor("num_dias"));
         } catch (Exception e) {
         }
       }
     }
   }
   return int_dias;
 }
Example #20
0
 /**
  * Valida que la clave no exista en el historial
  *
  * @param ide_usua Clave primaria del usuario
  * @param clave
  * @return
  */
 public boolean isClaveNueva(String ide_usua, String clave) {
   // Busco cuantas claves anteriores valido, estan sis_reglas
   TablaGenerica tab_reglas = getReglas();
   int int_num_antes = 0;
   try {
     int_num_antes = Integer.parseInt(tab_reglas.getValor("NUM_VALIDA_ANTERIOR_RECL"));
   } catch (Exception e) {
   }
   if (int_num_antes == 0) {
     // valido todas
     TablaGenerica tab_historia =
         utilitario.consultar(
             "SELECT * FROM sis_historial_claves where ide_usua="
                 + ide_usua
                 + " and clave_hicl='"
                 + encriptar.getEncriptar(clave)
                 + "'");
     return tab_historia.isEmpty();
   } else {
     TablaGenerica tab_historia =
         utilitario.consultar(
             "SELECT * FROM sis_historial_claves where ide_usua="
                 + ide_usua
                 + " order by FECHA_HICL desc");
     for (int i = 0; i < int_num_antes; i++) {
       if (tab_historia.getValor("CLAVE_HICL") != null
           && (tab_historia.getValor("CLAVE_HICL").equals(encriptar.getEncriptar(clave)))) {
         return false;
       }
     }
     return true;
   }
 }
Example #21
0
 @Override
 public boolean next() throws JRException {
   if (tabla != null) {
     return ++indice < tabla.getTotalFilas();
   } else if (tablaGenerica != null) {
     return ++indice < tablaGenerica.getTotalFilas();
   } else {
     return ++indice < lista.size();
   }
 }
Example #22
0
 /**
  * Verifica si el usuario tiene que cambiar su clave de acuerdo a los periodos de vigencia
  *
  * @param ide_usua Clave primaria del usuario
  */
 public void solicitarCambiarClave(String ide_usua) {
   // Obliga al usuario a cambiar su clave cada periodo de tiempoq tenga
   // asignado
   TablaGenerica tab_clave = getClaveActivaUusario(ide_usua);
   // Verifica si la clave activa del usuario tiene periodo de cambio de
   // contraseña
   if (tab_clave.isEmpty() == false) {
     int int_dias_cambio = getDiasPeriodoClave(tab_clave.getValor("ide_pecl"));
     if (int_dias_cambio > 0) {
       // fecha de registro de la clave + los dias q tiene q hacer el
       // cambio
       Date dat_fecha_cambio =
           utilitario.sumarDiasFecha(
               utilitario.getFecha(tab_clave.getValor("fecha_registro_uscl")), int_dias_cambio);
       Date dat_fecha_actual = new Date();
       int int_dias_diferencia =
           utilitario.getDiferenciasDeFechas(dat_fecha_cambio, dat_fecha_actual);
       if (int_dias_diferencia % int_dias_cambio == 0) {
         // Busca si el usuario ya cambio la clave el dia actual
         TablaGenerica tab_cambio =
             utilitario.consultar(
                 "SELECT * FROM SIS_AUDITORIA_ACCESO WHERE IDE_ACAU="
                     + P_SIS_CAMBIO_CLAVE
                     + " AND FECHA_AUAC="
                     + utilitario.getFormatoFechaSQL(utilitario.getFechaActual()));
         if (tab_cambio.isEmpty()) {
           // Debe cambiar la clave
           String str_sql =
               "UPDATE sis_usuario SET cambia_clave_usua=true WHERE IDE_USUA=" + ide_usua;
           utilitario.getConexion().ejecutarSql(str_sql);
         }
       }
     }
   }
 }
 public void busPlaca() {
   TablaGenerica tabDato =
       aCombustible.getVehiculo(Integer.parseInt(tabTabla.getValor("mve_secuencial")));
   if (!tabDato.isEmpty()) {
     if (tabDato.getValor("placa").equals("0000000")) {
       tabTabla.getColumna("abastecimiento_kilometraje").setLectura(true);
       tabTabla.getColumna("abastecimiento_cod_dependencia").setLectura(false);
       tabTabla.getColumna("tipo_combustible_id").setLectura(false);
       tabTabla.setValor("abastecimiento_tipo_ingreso", "O");
       utilitario.addUpdate("tabTabla");
     } else {
       tabTabla.setValor("abastecimiento_cod_conductor", tabDato.getValor("cod_conductor"));
       tabTabla.setValor("tipo_combustible_id", tabDato.getValor("tipo_combustible_id"));
       tabTabla.setValor(
           "abastecimiento_cod_dependencia", tabDato.getValor("departamento_pertenece"));
       tabTabla.getColumna("abastecimiento_kilometraje").setLectura(false);
       tabTabla.getColumna("abastecimiento_cod_dependencia").setLectura(true);
       tabTabla.getColumna("tipo_combustible_id").setLectura(true);
       tabTabla.setValor("abastecimiento_tipo_ingreso", "K");
       utilitario.addUpdate("tabTabla");
     }
   } else {
     utilitario.agregarMensajeError("Vehiculo", "No Se Encuentra Registrado");
   }
 }
Example #24
0
 public void datosUsuario() {
   TablaGenerica tab_dato = datosEmpledo.getDatoEmpleado(tab_solicitud.getValor("codigo_usuario"));
   if (!tab_dato.isEmpty()) {
     tab_solicitud.setValor("cedula_usuario", tab_dato.getValor("cedula_pass"));
     tab_solicitud.setValor("nombre_usuario", tab_dato.getValor("nombres"));
     tab_solicitud.setValor("cargo_usuario", tab_dato.getValor("cod_cargo"));
     tab_solicitud.setValor("direccion_usuario", tab_dato.getValor("cod_direccion"));
     utilitario.addUpdate("tab_solicitud");
   } else {
     utilitario.agregarMensaje("Usuario Sin Datos", "");
   }
 }
Example #25
0
 /**
  * Valida que el perfil del usuario este activo
  *
  * @param IDE_PERF
  */
 public boolean isPerfilActivo(String IDE_PERF) {
   TablaGenerica tab_perf =
       utilitario.consultar("SELECT * FROM SIS_PERFIL WHERE IDE_PERF=" + IDE_PERF);
   if (tab_perf.getValor("activo_perf") != null
       && (tab_perf.getValor("activo_perf").equals("true")
           || tab_perf.getValor("activo_perf").equals("1"))) {
     if (tab_perf.getValor("perm_util_perf") != null
         && (tab_perf.getValor("perm_util_perf").equals("true")
             || tab_perf.getValor("perm_util_perf").equals("1"))) {
       utilitario.crearVariable("PERM_UTIL_PERF", "true");
     } else {
       utilitario.crearVariable("PERM_UTIL_PERF", "false");
     }
     return true;
   }
   return false;
 }
Example #26
0
 /**
  * Consulta el número de intentos fallidos al tratar de acceder al sistema
  *
  * @param ide_usua Clave primaria del usuario
  * @param fecha Fecha de consulta
  * @return
  */
 public int getIntentosAcceso(String ide_usua, String fecha) {
   // Retorna el numero de intentos para acceder al sistema de un usuario
   // en un dia y por ip
   int int_intentos = 0;
   TablaGenerica tab_intentos =
       utilitario.consultar(
           "select ide_usua,count(*) as intentos from sis_auditoria_acceso where ide_usua="
               + ide_usua
               + " "
               + "and fecha_auac="
               + utilitario.getFormatoFechaSQL(fecha)
               + " and ip_auac='"
               + utilitario.getIp()
               + "' and fin_auac=false and ide_acau="
               + P_SIS_FALLO_INGRESO
               + " group by ide_usua");
   if (tab_intentos.isEmpty() == false) {
     try {
       int_intentos = Integer.parseInt(tab_intentos.getValor("intentos"));
     } catch (Exception e) {
     }
     // Cuenta los desbloqueos para otra ves encerar el numero de
     // intentos despues de q se desbloque el usuario
     TablaGenerica tab_desbloqueos =
         utilitario.consultar(
             "select ide_usua,count(*) as desbloqueos from sis_auditoria_acceso where ide_usua="
                 + ide_usua
                 + " "
                 + "and fecha_auac="
                 + utilitario.getFormatoFechaSQL(fecha)
                 + " and ip_auac='"
                 + utilitario.getIp()
                 + "' and ide_acau="
                 + P_SIS_DESBLOQUEA_USUARIO
                 + " group by ide_usua");
     if (tab_desbloqueos.isEmpty() == false) {
       int int_num_desbloqueos = 0;
       try {
         int_num_desbloqueos = Integer.parseInt(tab_desbloqueos.getValor("desbloqueos"));
       } catch (Exception e) {
       }
       if (int_num_desbloqueos > 0) {
         int_num_desbloqueos = int_num_desbloqueos * getNumeroIntentosAcceso();
         int_intentos = int_intentos - int_num_desbloqueos;
       }
     }
   }
   return int_intentos;
 }
 public void galones() {
   TablaGenerica tabDato =
       aCombustible.getVehiculo(Integer.parseInt(tabTabla.getValor("mve_secuencial")));
   if (!tabDato.isEmpty()) {
     if (tabDato.getValor("placa").equals("0000000")) {
       valor();
       carga();
       secuencial();
     } else {
       if (!tabTabla.getValor("abastecimiento_kilometraje").isEmpty()) {
         Double valor1 = Double.valueOf(tabDato.getValor("capacidad_tanque"));
         Double valor2 = Double.valueOf(tabTabla.getValor("abastecimiento_galones"));
         if (valor2 <= valor1) {
           utilitario.addUpdate("tabTabla");
           valor();
           carga();
           secuencial();
         } else {
           utilitario.agregarMensajeError("Galones", "Exceden Capacidad de Vehiculo");
           tabTabla.setValor("abastecimiento_galones", null);
           utilitario.addUpdate("tabTabla");
         }
       } else {
         if (!tabDato.getValor("kilometros_actual").isEmpty()) {
           utilitario.agregarMensaje("Posee Historial de Kilometraje", null);
         } else {
           Double valor1 = Double.valueOf(tabDato.getValor("capacidad_tanque"));
           Double valor2 = Double.valueOf(tabTabla.getValor("abastecimiento_galones"));
           if (valor2 <= valor1) {
             utilitario.addUpdate("tabTabla");
             valor();
             carga();
             secuencial();
           } else {
             utilitario.agregarMensajeError("Galones", "Exceden Capacidad de Vehiculo");
             tabTabla.setValor("abastecimiento_galones", null);
             utilitario.addUpdate("tabTabla");
           }
         }
       }
     }
   } else {
     utilitario.agregarMensajeError("Valor", "No Se Encuentra Registrado");
   }
 }
Example #28
0
 /**
  * Valida si una clave cumple con las reglas definidas en la tabla
  *
  * @param clave
  * @return Mensaje de error si fallo alguna validación, caso contrario retorna vacio
  */
 public String getClaveValida(String clave) {
   // Valida si la clave cumple con las reglas minimas definidas
   String str_mensaje = "No se a definido reglas para las claves";
   TablaGenerica tab_regla = getReglas();
   if (tab_regla.isEmpty() == false) {
     int int_longitud_minima = 0;
     int int_num_carac_espe = 0;
     int int_num_mayus = 0;
     int int_num_minusc = 0;
     int int_num_numeros = 0;
     try {
       int_longitud_minima = Integer.parseInt(tab_regla.getValor("longitud_minima_recl"));
     } catch (Exception e) {
     }
     try {
       int_num_carac_espe = Integer.parseInt(tab_regla.getValor("num_carac_espe_recl"));
     } catch (Exception e) {
     }
     try {
       int_num_mayus = Integer.parseInt(tab_regla.getValor("num_mayus_recl"));
     } catch (Exception e) {
     }
     try {
       int_num_minusc = Integer.parseInt(tab_regla.getValor("num_minusc_recl"));
     } catch (Exception e) {
     }
     try {
       int_num_numeros = Integer.parseInt(tab_regla.getValor("num_numeros_recl"));
     } catch (Exception e) {
     }
     // Cuento las reglas de la clave
     int int_con_longitud_minima = 0;
     int int_con_num_carac_espe = 0;
     int int_con_num_mayus = 0;
     int int_con_num_minusc = 0;
     int int_con_num_numeros = 0;
     for (int i = 0; i < clave.length(); i++) {
       char chr_actual = clave.charAt(i);
       int_con_longitud_minima++;
       if (Character.isLetterOrDigit(chr_actual)) {
         if (Character.isLetter(chr_actual)) {
           if (Character.isUpperCase(chr_actual)) {
             int_con_num_mayus++;
           } else {
             int_con_num_minusc++;
           }
         } else {
           int_con_num_numeros++;
         }
       } else {
         int_con_num_carac_espe++;
       }
     }
     // Comparo si cumple con todo
     if (int_con_longitud_minima < int_longitud_minima) {
       str_mensaje =
           "La clave ingresada no cumple con la regla de longitud mínima = " + int_longitud_minima;
     } else {
       if (int_con_num_carac_espe < int_num_carac_espe) {
         str_mensaje =
             "La clave ingresada no cumple con la regla de cantidad mínima de caracteres especiales = "
                 + int_num_carac_espe;
       } else {
         if (int_con_num_mayus < int_num_mayus) {
           str_mensaje =
               "La clave ingresada no cumple con la regla de cantidad mínima de letras mayúsculas = "
                   + int_num_mayus;
         } else {
           if (int_con_num_minusc < int_num_minusc) {
             str_mensaje =
                 "La clave ingresada no cumple con la regla de cantidad mínima de letras minúsculas = "
                     + int_num_minusc;
           } else {
             if (int_con_num_numeros < int_num_numeros) {
               str_mensaje =
                   "La clave ingresada no cumple con la regla de cantidad mínima de caracteres numéricos = "
                       + int_num_numeros;
             } else {
               str_mensaje = "";
             }
           }
         }
       }
     }
   }
   return str_mensaje;
 }
 @Override
 public void guardar() {
   if (tabTabla.getValor("abastecimiento_id") != null) {
     TablaGenerica tabInfo =
         bCombustible.getCatalogoDato(
             "*",
             tabTabla.getTabla(),
             "abastecimiento_id = " + tabTabla.getValor("abastecimiento_id") + "");
     if (!tabInfo.isEmpty()) {
       TablaGenerica tabDato = bCombustible.getNumeroCampos(tabTabla.getTabla());
       if (!tabDato.isEmpty()) {
         for (int i = 1; i < Integer.parseInt(tabDato.getValor("NumeroCampos")); i++) {
           if (i != 1) {
             TablaGenerica tabInfoColum1 = bCombustible.getEstrucTabla(tabTabla.getTabla(), i);
             if (!tabInfoColum1.isEmpty()) {
               try {
                 if (tabTabla
                     .getValor(tabInfoColum1.getValor("Column_Name"))
                     .equals(tabInfo.getValor(tabInfoColum1.getValor("Column_Name")))) {
                 } else {
                   bCombustible.setActuaRegis(
                       Integer.parseInt(tabTabla.getValor("abastecimiento_id")),
                       tabTabla.getTabla(),
                       tabInfoColum1.getValor("Column_Name"),
                       tabTabla.getValor(tabInfoColum1.getValor("Column_Name")),
                       "abastecimiento_id");
                 }
               } catch (NullPointerException e) {
               }
             }
           }
         }
       }
     }
     utilitario.agregarMensaje("Registro Actalizado", null);
   } else {
     if (tabTabla.guardar()) {
       conPostgres.guardarPantalla();
     }
     actu();
   }
 }
Example #30
0
 /**
  * Verifica si un usuario tiene una clave activa
  *
  * @param ide_usua Clave primaria del usuario
  * @return
  */
 public boolean isClaveActiva(String ide_usua) {
   TablaGenerica tab_clave = getClaveActivaUusario(ide_usua);
   return tab_clave.isEmpty();
 }