////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   ///////////////////////////////                                              //
//   ///// C A D E N A S . J S /////                                              //
//   ///////////////////////////////                                              //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Archivo que contiene funciones para validación y modificación de cadenas  //
//                                                                                //
//   Funciones:                                                                   //
//      - ValidaCad                                                               //
//      - ValidaCadFormu                                                          //
//      - ValidaCadCorreo                                                         //
//      - ValidaCadNumero                                                         //
//      - SustituyeBlancos                                                        //
//      - SustituyeBlancosFormu                                                   //
//      - ValorSlct                                                               //
//      - Rtrim                                                                   //
//      - Ltrim                                                                   //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   /////////////////////////////                                                //
//   ///// V A L I D A C A D /////                                                //
//   /////////////////////////////                                                //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Comprueba si una cadena contiene algún carácter usado por el formato GET  //
//      de CGIs.                                                                  //
//                                                                                //
//   Parametros:                                                                  //
//      Entrada->                                                                 //
//         cadena: La cadena a comprobar si contiene algún carácter utilizado por //
//                 el formato GET de CGIs.                                        //
//      Salida->                                                                  //
//         true: si la cadena NO contiene algún carácter usado por el formato.    //
//         false: si la cadena contiene algún carácter usado por el formato.      //
//                                                                                //
//   Modificaciones:                                                              //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

function ValidaCad(cadena) {    

    ampersan = cadena.indexOf("&");
    igual = cadena.indexOf("=");
    interrogacion = cadena.indexOf("?");
    mas = cadena.indexOf("+");
    almohadilla = cadena.indexOf("#");
    dospuntos = cadena.indexOf(":");
    barra = cadena.indexOf("/");

    if ( (ampersan != -1) || (igual != -1) || (interrogacion != -1) || (mas != -1) ||(almohadilla != -1) || (dospuntos != -1) || (barra != -1)) {
        return false;
    } else {
        return true;
    }
}

////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   ///////////////////////////////////////                                      //
//   ///// V A L I D A C A D F O R M U /////                                      //
//   ///////////////////////////////////////                                      //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Comprueba si en un formulario los input-text y los textarea contienen     //
//      algún carácter usado por el formato GET de CGIs.                          //
//                                                                                //
//   Parametros:                                                                  //
//      Entrada->                                                                 //
//         cadena: La cadena a comprobar si contiene algún carácter utilizado por //
//                 el formato GET de CGIs.                                        //
//      Salida->                                                                  //
//         - Da un alert con la cadena que tiene un carácter usado por el CGI.    //
//         true: si la cadena contiene algún carácter usado por el formato.       //
//         false: si la cadena NO contiene algún carácter usado por el formato.   //
//                                                                                //
//   Modificaciones:                                                              //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

function ValidaCadFormu(formula) {
    for (i = 0 ; i < formula.length ; i++) {
        tempobj = formula.elements[i];
        if ((tempobj.type == "text")||(tempobj.type == "textarea")) {
            if (tempobj.value.length!=0) {
                if (ValidaCad(tempobj.value)==false) {
                    alert("La cadena de caractéres " + tempobj.value + " contiene caractéres no válidos.");
                    return false;
                }
            }
        }
    }
    return true;
}

////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   /////////////////////////////////////////                                    //
//   ///// V A L I D A C A D C O R R E O /////                                    //
//   /////////////////////////////////////////                                    //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Comprueba si una cadena contiene los caracteres necesarios mínimos para   //
//      ser una dirección de correo.                                              //
//                                                                                //
//   Parametros:                                                                  //
//      Entrada->                                                                 //
//         cadena: La cadena a comprobar si contiene los caracteres necesarios    //
//                 mínimos.                                                       //
//      Salida->                                                                  //
//         - Da un alert diciendo que la cadena no puede ser una dirección de     //
//           correo.                                                              //
//         true: si la cadena contiene los caracteres necesarios mínimos o vacio. //
//         false: si la cadena NO contiene los caracteres necesarios mínimos.     //
//                                                                                //
//   Modificaciones:                                                              //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

function ValidaCadCorreo(cadena) {    

    if (cadena.length == 0) {
    	return true;
    }
    espacio = cadena.indexOf(" ");
    if (espacio != -1) {
    	alert("La cuenta de correo:"+ cadena +" no es válida tiene espacios en blanco.");
    	return false;
    }
    
    arroba = cadena.indexOf("@");
    if (arroba == -1) {
    	alert("La cuenta de correo:"+ cadena +" no es válida no tiene arroba.");
    	return false;
    } else {
        punto = cadena.indexOf(".",arroba+2);
        if (punto == -1) {
    	    alert("La cuenta de correo:"+ cadena +" no tiene al menos un punto después del nombre de dominio.");
    	    return false;
        } else {
            return true;
        }
    }
    
}

////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   /////////////////////////////////////////                                    //
//   ///// V A L I D A C A D N Ú M E R O /////                                    //
//   /////////////////////////////////////////                                    //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Comprueba si una cadena no es mumérica.                                   //
//                                                                                //
//   Parametros:                                                                  //
//      Entrada->                                                                 //
//         cadena: La cadena a comprobar si es numérica.                          //
//      Salida->                                                                  //
//         true: si la cadena es numérica o vacia.                                //
//         false: si la cadena No es numérica.                                    //
//                                                                                //
//   Modificaciones:                                                              //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

function ValidaCadNumero (cadena){
    if (cadena.length != 0) {
        i = 0;
        e = 0;
        while (i < cadena.length) {
            ncadena = cadena.substring(i,i+1);      	
            if ((ncadena != "0") && (ncadena != "1") && (ncadena != "2") && (ncadena != "3") && (ncadena != "4") && (ncadena != "5") && (ncadena != "6") && (ncadena != "7") && (ncadena != "8") && (ncadena !="9")) { 
                e = 1;
            } 
      	    i = i + 1;
        }
        if (e == 1) {
            return false;
        }else{
            return true;
        }
    } else {
        return true;
    }
}

////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   ///////////////////////////////////////////                                  //
//   ///// S U S T I T U Y E B L A N C O S /////                                  //
//   ///////////////////////////////////////////                                  //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Sustituye en una cadena los espacios en blanco en %27                     //
//                                                                                //
//   Parametros:                                                                  //
//      Entrada->                                                                 //
//         cadena: La cadena a sustituir los espacios en blanco por %27.          //
//      Salida->                                                                  //
//         ncadena: La cadena a sustituida.                                       //
//                                                                                //
//   Modificaciones:                                                              //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

function SustituyeBlancos(cadena) {
    ncadena = cadena.replace(cadena, "%27");
    return (ncadena);                          
}

////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   /////////////////////////////////////////////////////                        //
//   ///// S U S T I T U Y E B L A N C O S F O R M U /////                        //
//   /////////////////////////////////////////////////////                        //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Sustituye en los campos tipo input-text y textarea de un formulario los   //
//      espacios en blanco por %27.                                               //
//                                                                                //
//   Parametros:                                                                  //
//      Entrada->                                                                 //
//         formu: Formulario a sustituir los espacios en blanco por %27.          //
//      Salida->                                                                  //
//         - Cambia el valor de cada campo input-text o textarea sustitido los    //
//           espacios por %27.                                                    //
//                                                                                //
//   Modificaciones:                                                              //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

function SustituyeBlancosFormu(formu) {
    for (i = 0 ; i < formula.length ; i++) {
        tempobj = formula.elements[i];
        if ((tempobj.type == "text")||(tempobj.type == "textarea")) {
            if (tempobj.value.length!=0) {
                tempobj.value = SustituyeBlancos(tempobj.value)
            }
        }
    }
}

////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   /////////////////////////////                                                //
//   ///// V A L O R S L C T /////                                                //
//   /////////////////////////////                                                //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Dado un objeto select-one devuelve el valor de la opción elegida.         //                                              //
//                                                                                //
//   Parametros:                                                                  //
//      Entrada->                                                                 //
//         slct: El Select del que queremos el valor.                             //
//      Salida->                                                                  //
//         valor: El valor que tenga el atributo value de la opción selected.     //
//                                                                                //
//   Modificaciones:                                                              //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

function ValorSlct(slct) {
    valor = slct.options[slct.selectedIndex].value;
    return valor;
}

////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   /////////////////////                                                        //
//   ///// R T R I M /////                                                        //
//   /////////////////////                                                        //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Extrae los espacios en blanco que se encuentren al principio de la cadena //
//      que aparece en un elemento del formulario (input-text, textArea)          //
//                                                                                //
//   Parametros:                                                                  //
//      Entrada->                                                                 //
//         cuadroTexto: El input-text o el textarea del que queremos borrar los   //
//                      espacios en blanco.                                       //
//      Salida->                                                                  //
//         - El valor que tenga el cuadroTexto borrados los espacios en blanco.   //
//                                                                                //
//   Modificaciones:                                                              //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

function Rtrim(cuadroTexto)
{
    while((''+cuadroTexto.value.charAt(cuadroTexto.value.length-1)==' ') || (''+cuadroTexto.value.charAt(cuadroTexto.value.length-1)=="\n"))
        cuadroTexto.value=cuadroTexto.value.substring(0,cuadroTexto.value.length-1);
}

////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//   /////////////////////                                                        //
//   ///// L T R I M /////                                                        //
//   /////////////////////                                                        //
//                                                                                //
//   Autor: David Jesús de Frutos Sanz                                            //
//   F. Creación: 09-nov-01                                                       //
//                                                                                //
//   Definición:                                                                  //
//      Extrae los espacios en blanco que se encuentren al final de la cadena     //
//      que aparece en un elemento del formulario (input-text, textArea)          //
//                                                                                //
//   Parametros:                                                                  //
//      Entrada->                                                                 //
//         cuadroTexto: El input-text o el textarea del que queremos borrar los   //
//                      espacios en blanco.                                       //
//      Salida->                                                                  //
//         - El valor que tenga el cuadroTexto borrados los espacios en blanco.   //
//                                                                                //
//   Modificaciones:                                                              //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

function Ltrim(cuadroTexto)
{
        while( (''+cuadroTexto.value.charAt(0)==' ') || (''+cuadroTexto.value.charAt(cuadroTexto.value.length-1)=="\n"))
                cuadroTexto.value=cuadroTexto.value.substring(1,cuadroTexto.value.length);
}
