/************************************************************************************************************** Soluciones Integrales GIS 2005 Autor: Rafael Pellicer. ************************************************************************************************************** --------------------------- Objeto Validator: Objeto que se encarga de la validación de los campos de un formulario. --------------------------- CONSTRUCTOR. myValidator = new Validator(string, [boolean]); Return: (Objeto Validator) Parametros: 1. Id del formulario que se quiere validar. 2. True = Modo Debug / False = Modo No Debug ATRIBUTOS. myValidator.FocusOnError = boolean -> En caso de error dá el foco al primer control (con error) TRUE/FALSE myValidator.SelectOnFocus = boolean -> Se selecciona el contenido del text TRUE/FALSE MÉTODOS * add: Añade el control que se quiere validar. myValidator.add(string, integer, [string], [boolean]); Return: (None) Parametros: 1. Id del control que se quiere validar. 2. Tipo de validación que se desea aplicar. Los tipos de validación que se pueden aplicar son: (VER: Constantes para Validación) 3. Parámetro opcional que indica un alias para el control que se está validando. Este alias es usado para dar mensajes al usuario. Si se coloca Null o Vacío el alias será el nombre del control. 4. Parámetro opcional, donde: True Indica que el campo no va a ser validado a menos que contenga un valor distindo de vacío. FALSE (Valor por defecto) indica que el campo es requerido y será validado con o sin contenido. * check: Realiza las validaciones con los controles añadidos. myValidator.check(); Return: TRUE en el caso de que el form esté validado; FALSE en el caso contrario. Parametros: (None) * getErrors: Devuelve los errores ocurridos durante la validación myValidator.getErrors([boolean]); Return: (string) Parametros: 1. Parámetro opcional donde: TRUE = indica que se va a retornar un string con la lista de errores encontrados durante la validación. FALSE= (Valor por defecto) indica que el objeto debe emitir un alert con la lista de errores. --------------------------- Functiones de Validación --------------------------- esSoloNumeros : Recibe un texto y devuelve true si está compuesto solo por números 0-9 esSoloLetras : Recibe un texto y devuelve true si está compuesto solo por letras A-Z y/o a-z esAlfaNumerico : Determina que un texto esté solo compuesto por letras y números 0-9 y/o A-Z y/o a-z esAlfaNumericog: Determina que un texto esté solo compuesto por letras y números 0-9, A-Z, a-z, _ esFecha : Verifica que una fecha tenga el formato correcto dd/mm/yyyy. esHora : Determina si tiene formato de hora hh:mm am/pm. esVacio : Determina si una cadena tiene o no, caracteres. esReal : Recibe cadena que permite conocer si presenta el formato correcto de número real. Decimales con . (punto) esEntero : Recibe un número entero y devuelve true si esta en el formato correcto. esNombrePropio : Valida que el valor tenga los caracteres permitidos en los nombre propios. esNombreEmpresa: Valida que el valor tenga los caracteres permitidos en los nombre de empresas. esEmail : Valida que el texto tenga formato de e-mail. esTelefono : Valida que solo tenga los caracteres comunes en los número telefónicos esAno : Determina si es un formato válido de año yyyy TieneComillas : Recibe una cadena y devuelve true si tiene comillas simples (') o dobles ("). CompFechaHora : Compara fechas con horas. f1 y f2 deben estar en formato dd/mm/yyyy esSeleccionado : Determina si está seleccionado un OPTION del objeto SELECT. esIndexCero : Determina si el index del OPTION seleccionado es cero. --------------------------- Functiones de Conversión --------------------------- toMMDDYYYY : Convierte la fecha de formato dd/mm/yyyy a mm/dd/yyyy toDDMMYYYY : Convierte la fecha de formato mm/dd/yyyy a dd/mm/yyyy Horato24H : Convierte la hora a formato 24H. FormatoMoneda : Convierte un número a formato moneda: Bs.1.000.000,00 --------------------------- Functiones utilitarias --------------------------- Reemplaza : Reemplaza coincidencias en una cadena por otra. Trim : Elimina los espacios en blanco a ambos extremos de una cadena LTrim : Elimina los espacios en blanco de la izquierda de una cadena. RTrim : Elimina los espacios en blanco de la derecha de una cadena. **************************************************************************************************************/ // ------------------------------------------------------------------------- // Constantes para Validación. // ------------------------------------------------------------------------- CONST_TODOS = -1; CONST_NUMEROS = 1; CONST_LETRAS = 2; CONST_ALFANUMERICO = 3; CONST_FECHA = 4; CONST_HORA12 = 5; CONST_HORA24 = 6; CONST_REAL = 7; CONST_ENTERO = 8; CONST_NOMBREPROPIO = 9; CONST_NOMBREMPRESA = 10; CONST_EMAIL = 11; CONST_TELEFONO = 12; CONST_ANO = 13; CONST_INDEXCERO = 14; CONST_ALFANUMERICOG = 15; // ------------------------------------------------------------------------- // Constantes de Mensajes. // ------------------------------------------------------------------------- CONST_MSG_ALIAS = "-r33Mp1420-"; CONST_MSG_REQUERIDO = "El campo " + CONST_MSG_ALIAS + " es requerido."; CONST_MSG_NUMEROS = "El campo " + CONST_MSG_ALIAS + " solo debe contener números."; CONST_MSG_LETRAS = "El campo " + CONST_MSG_ALIAS + " solo debe contener letras."; CONST_MSG_ALFANUMERICO = "El campo " + CONST_MSG_ALIAS + " solo debe contener números y letras."; CONST_MSG_FECHA = "El campo " + CONST_MSG_ALIAS + " no tiene el formato de fecha."; CONST_MSG_HORA12 = "El campo " + CONST_MSG_ALIAS + " tiene formato incorrecto."; CONST_MSG_HORA24 = "El campo " + CONST_MSG_ALIAS + " tiene formato incorrecto."; CONST_MSG_REAL = "El campo " + CONST_MSG_ALIAS + " debe ser un número real."; CONST_MSG_ENTERO = "El campo " + CONST_MSG_ALIAS + " debe ser un número entero."; CONST_MSG_NOMBREPROPIO = "El campo " + CONST_MSG_ALIAS + " tiene caracteres inválidos."; CONST_MSG_NOMBREMPRESA = "El campo " + CONST_MSG_ALIAS + " tiene caracteres inválidos."; CONST_MSG_EMAIL = "El campo " + CONST_MSG_ALIAS + " tiene caracteres inválidos o el formato es incorrecto."; CONST_MSG_TELEFONO = "El campo " + CONST_MSG_ALIAS + " tiene caracteres inválidos o el formato es incorrecto."; CONST_MSG_ANO = "El campo " + CONST_MSG_ALIAS + " debe ser numérico y de longitud 4."; CONST_MSG_INDEXCERO = "Debe seleccionar el " + CONST_MSG_ALIAS + "."; CONST_MSG_ALFANUMERICOG = "El campo " + CONST_MSG_ALIAS + " tiene caracteres inválidos o el formato es incorrecto."; // ------------------------------------------------------------------------- // Configuración de Expresiones Regulares. // ------------------------------------------------------------------------- REG_EXP_SOLONUM = /[^0-9]/; REG_EXP_SOLOLET = /^([a-z]|[A-Z]|'|á|é|í|ó|ú|ñ|ü|Á|É|Í|Ó|Ú|Ñ|Ü)+$/; REG_EXP_ALFANUM = /[^a-zA-Z0-9\s]/; REG_EXP_DATECHARS = /[^0-9|\/\s]/; REG_EXP_DATE12H = /^([0][1-9]|1[0-2])\:([1-5]0|[0-5][0-9])\ (am|pm|AM|PM)$/; REG_EXP_DATE24H = /^([0][0-9]|1[0-9]||2[0-4])\:([0-6][0-9])$/; REG_EXP_VACIO = /[^*\s]/; REG_EXP_REAL = /^\-?\d{1,}$|^\-?\d*\.\d{1,}$/; REG_EXP_ENTERO = /^-[0-9]+$|^[0-9]+$/; REG_EXP_NOMBPROP = /^([a-z]|[A-Z]|'|á|é|í|ó|ú|ñ|ü|Á|É|Í|Ó|Ú|Ñ|Ü|\s|\'|\-)+$/; REG_EXP_NOMBEMP = /^([0-9]|[a-z]|[A-Z]|'|á|é|í|ó|ú|ñ|ü|Á|É|Í|Ó|Ú|Ñ|Ü|\s|\'|-)+$/; REG_EXP_EMAIL = /^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/; REG_EXP_TELEFONO = /^[\+]?[(]?(\d{0,3}\s?\d{0,3})[)]?[\s]?[-]?(\d{3})[\s]?[-]?[\.]?(\d{4})[\s]?[x]?(\d*|\s*)$/; REG_EXP_ANO = /^([0-9][0-9][0-9][0-9])$/; REG_EXP_COMILLAS = /\'|\"/; REG_EXP_ALFANUM_G = /[^a-zA-Z0-9_]/; // ------------------------------------------------------------------------- // Objeto para validar formularios // ------------------------------------------------------------------------- function Validator(_id_formulario, debug){ // Atributos GlobalObj = this; GlobalObj.Formulario = null GlobalObj.isDebug = debug; GlobalObj.FocusOn = null; GlobalObj.FocusOnError = null; GlobalObj.SelectOnFocus = null; // Colecciones GlobalObj.aControles = new Array(); GlobalObj.aErrors = new Array(); // Métodos. GlobalObj.add = addControl; GlobalObj.check = Check; GlobalObj.getErrors = ShowErrorsAlert; // Constructor. ValidatorConstructor(_id_formulario); function ValidatorConstructor(_idform){ var flag = true; if (_idform && !esVacio(_idform)){ GlobalObj.Formulario = getObject(_idform); GlobalObj.FocusOnError = true; GlobalObj.SelectOnFocus = true; }else{ GlobalObj.Formulario =null; alert("Debe pasar como parámetro el id del formulario con el que vá a trabajar.\n No se ha podido construir el objeto."); } } // Objeto que almacena los atributos de un error function Error(desc, FormObj){ this.descripcion = desc; this.SourceControl = FormObj; return this; } // Objeto que almacena los atributos que nos interesa de un control. function ObjetoEnDocumento(_obj, _tipo, _alias, _checkOnlyIfNotEmpty){ this.objeto = _obj; this.tipo = _tipo; this.alias = _alias; this.CheckOnlyIfNotEmpty = _checkOnlyIfNotEmpty; return this; } // Añade un control al array de controles que van a ser validados. function addControl(_id_ctrl, _type, _Alias, _checkOnlyIfNotEmpty){ var myControl = getObject(_id_ctrl); if (!_checkOnlyIfNotEmpty) _checkOnlyIfNotEmpty=false; if (myControl && _type){ var myObj = null; myObj = new ObjetoEnDocumento(myControl, _type, _Alias, _checkOnlyIfNotEmpty); GlobalObj.aControles.push(myObj); } } // Obtiene un control del documento por medio de su ID. function getObject(_idObj){ var myObj = document.getElementById(_idObj); var retVal = null; if (!myObj){ if (GlobalObj.isDebug) alert("No se encuentra el control con id: [" + _idObj + "]"); }else{ retVal = myObj; } return(retVal); } // Añade un error a la coleccion (err Array) function addError(descripcion, FormObj){ var oError = new Error(descripcion, FormObj); GlobalObj.aErrors.push(oError); } // Destruye el array de errores. function DeleteErrorArray(){ do{ GlobalObj.aErrors.pop(); }while(GlobalObj.aErrors.length>0); } // Muestra o devuelve el listado de errores encontrados. function ShowErrorsAlert(_ShowAlert){ var retVal = ""; if (GlobalObj.aErrors.length>0){ retVal = "Se han encontrado algunos errores:\n\n"; for (i=0; i < GlobalObj.aErrors.length; i++){ retVal = retVal + "- " + GlobalObj.aErrors[i].descripcion + "\n"; } if (!_ShowAlert){ return (retVal) }else{ retVal = retVal + "\n\n" + "Por favor, corrija e intente de nuevo." alert(retVal); if (GlobalObj.FocusOnError){ GlobalObj.FocusOn.focus(); if (GlobalObj.SelectOnFocus && GlobalObj.FocusOn.type == "text" ){ GlobalObj.FocusOn.select(); } GlobalObj.FocusOn = null; } } }else{ return retVal; } } // Realiza el chequeo a todos los controles function Check(){ var retVal = true; if (!GlobalObj.Formulario){ alert("No se ha encontrado el objeto Validator.") return; } DeleteErrorArray(); if (GlobalObj.aControles.length <=0){ if (GlobalObj.isDebug) alert("No se han encontrado controles y sus tipos para validar"); retVal = false; }else{ for (i=0; i < GlobalObj.aControles.length; i++){ var sErr = ""; var _objid = GlobalObj.aControles[i].objeto.id; var _tipo = GlobalObj.aControles[i].objeto.type; var _tipo_validacion = GlobalObj.aControles[i].tipo; var _alias = GlobalObj.aControles[i].alias; var _ChequeaSiNoEsVacio = GlobalObj.aControles[i].CheckOnlyIfNotEmpty; if (GlobalObj.aControles[i].objeto.type=="text" || GlobalObj.aControles[i].objeto.type=="password" || GlobalObj.aControles[i].objeto.type=="textarea"){ var _valor = GlobalObj.aControles[i].objeto.value; } if (GlobalObj.aControles[i].objeto.type=="select-one"){ var _valor = GlobalObj.aControles[i].objeto.options[GlobalObj.aControles[i].objeto.selectedIndex].text; _ChequeaSiNoEsVacio = true; } if (!_alias || esVacio(_alias)) _alias = GlobalObj.aControles[i].objeto.name; if (esVacio(_valor)){ if (!_ChequeaSiNoEsVacio){ retVal = false; sErr = Reemplaza(CONST_MSG_REQUERIDO, CONST_MSG_ALIAS, _alias); } }else{ switch(_tipo_validacion){ case CONST_TODOS: break; case CONST_NUMEROS: if (!esSoloNumeros(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_NUMEROS, CONST_MSG_ALIAS, _alias); } break; case CONST_LETRAS: if (!esSoloLetras(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_LETRAS, CONST_MSG_ALIAS, _alias); } break; case CONST_ALFANUMERICO: if (!esAlfaNumerico(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_ALFANUMERICO, CONST_MSG_ALIAS, _alias); } break; case CONST_FECHA: if (!esFecha(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_FECHA, CONST_MSG_ALIAS, _alias); } break; case CONST_HORA12: if (!esHora(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_HORA12, CONST_MSG_ALIAS, _alias); } break; case CONST_HORA24: if (!esHora(_valor, "24H")){ retVal = false; sErr = Reemplaza(CONST_MSG_HORA24, CONST_MSG_ALIAS, _alias); } break; case CONST_REAL: if (!esReal(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_REAL, CONST_MSG_ALIAS, _alias); } break; case CONST_ENTERO: if (!esEntero(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_ENTERO, CONST_MSG_ALIAS, _alias); } break; case CONST_NOMBREPROPIO: if (!esNombrePropio(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_NOMBREPROPIO, CONST_MSG_ALIAS, _alias); } break; case CONST_NOMBREMPRESA: if (!esNombreEmpresa(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_NOMBREMPRESA, CONST_MSG_ALIAS, _alias); } break; case CONST_EMAIL: if (!esEmail(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_EMAIL, CONST_MSG_ALIAS, _alias); } break; case CONST_TELEFONO: if (!esTelefono(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_TELEFONO, CONST_MSG_ALIAS, _alias); } break; case CONST_ANO: if (!esAno(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_ANO, CONST_MSG_ALIAS, _alias); } break; case CONST_INDEXCERO: if (esIndexCero(_objid)){ retVal = false; sErr = Reemplaza(CONST_MSG_INDEXCERO, CONST_MSG_ALIAS, _alias); } break; case CONST_ALFANUMERICOG: if (!esAlfaNumericog(_valor)){ retVal = false; sErr = Reemplaza(CONST_MSG_ALFANUMERICOG, CONST_MSG_ALIAS, _alias); } break; default: retVal = false; if (GlobalObj.isDebug){ sErr =null; alert("No se encuentra el tipo de validación que intenta realizar al campo '" + _alias + "'.") } } } if (sErr && sErr != ""){ if (!GlobalObj.FocusOn) GlobalObj.FocusOn = GlobalObj.aControles[i].objeto; addError(sErr, GlobalObj.aControles[i].objeto); }else if (sErr== "ERROR"){ break; } } } return(retVal); } } // ************************************************************************* // Listado de functiones de validación // ************************************************************************* // ------------------------------------------------------------------------- // Recibe una cadena y devuelve true si está compuesto solo por números. // de lo contrario devuelve falso. // ------------------------------------------------------------------------- function esSoloNumeros(value){ var PNum = new String(value); var myRegExp = new RegExp(REG_EXP_SOLONUM); return !myRegExp.test(PNum); } // ------------------------------------------------------------------------- // Recibe un texto y devuelve true si está compuesto solo letras. // de lo contrario devuelve falso. // ------------------------------------------------------------------------- function esSoloLetras(value){ var sVal = new String(value); var myRegExp = new RegExp(REG_EXP_SOLOLET); return myRegExp.test(sVal); } // ------------------------------------------------------------------------- // Determina que un texto esté solo compuesto por letras y números // ------------------------------------------------------------------------- function esAlfaNumerico(value){ var sVal = new String(value); var myRegExp = new RegExp(REG_EXP_ALFANUM); return !myRegExp.test(sVal); } // ------------------------------------------------------------------------- // Determina que un texto esté solo compuesto por letras, números y underscore // ------------------------------------------------------------------------- function esAlfaNumericog(value){ var sVal = new String(value); var myRegExp = new RegExp(REG_EXP_ALFANUM_G); return !myRegExp.test(sVal); } // ------------------------------------------------------------------------- // Verifica que una fecha tenga el formato correcto dd/mm/yyyy. // ------------------------------------------------------------------------- function esFecha(DateValue){ var checkstr = "0123456789"; var Datevalue = ""; var DateTemp = ""; var seperator = "/"; var day; var month; var year; var leap = 0; var err = 0; var i; err = 0; // Verifica que no tenga caracteres diferentes a 0-9 y / var regExp = /[^0-9|\/\s]/; if (regExp.test(DateValue)) return false; // Delete all chars except 0..9 for (i = 0; i < DateValue.length; i++) { if (checkstr.indexOf(DateValue.substr(i,1)) >= 0) { DateTemp = DateTemp + DateValue.substr(i,1); } } DateValue = DateTemp; if (DateValue.length != 8) { err = 19; } // year is wrong if year = 0000 year = DateValue.substr(4,4); if (year == 0) { err = 20; } /* Validation of month*/ month = DateValue.substr(2,2); if ((month < 1) || (month > 12)) { err = 21; } /* Validation of day*/ day = DateValue.substr(0,2); if (day < 1) { err = 22; } /* Validation leap-year / february / day */ if ((year % 4 == 0) || (year % 100 == 0) || (year % 400 == 0)) { leap = 1; } if ((month == 2) && (leap == 1) && (day > 29)) { err = 23; } if ((month == 2) && (leap != 1) && (day > 28)) { err = 24; } /* Validation of other months */ if ((day > 31) && ((month == "01") || (month == "03") || (month == "05") || (month == "07") || (month == "08") || (month == "10") || (month == "12"))) { err = 25; } if ((day > 30) && ((month == "04") || (month == "06") || (month == "09") || (month == "11"))) { err = 26; } if (err == 0) { //DateField.value = day + seperator + month + seperator + year; return(true); } /* Error-message if err != 0 */ else { return(false); } } // ------------------------------------------------------------------------- // Determina si la cadena que se pasa tiene formato de hora. // parametros: // Hora = Cadena con hora // format = 24H/12H (Parametro opcional. Por defecto 12H) // -------------------------------------------------------------------------- function esHora(Hora, format){ var retVal = 0; if (format != "24H"){ var myRegExp = new RegExp(REG_EXP_DATE12H); var longitud = 8; }else{ var myRegExp = new RegExp(REG_EXP_DATE24H); var longitud = 5; } var retVal = true; if (Hora.length > 0){ if (Hora.length != longitud){ retVal = false; }else{ if (!(myRegExp.test(Hora))){ retVal = false; } } } return (retVal); } // ------------------------------------------------------------------------- // Determina si el parámetro que se pasa tiene caracter alguno // Devuelve true si es vacía. De lo contrario false. // ------------------------------------------------------------------------- function esVacio(value){ var myRegExp = new RegExp(REG_EXP_VACIO); return !myRegExp.test(value); } // ------------------------------------------------------------------------- // Recibe cadena que permite conocer si presenta el formato correcto de // número real. // ------------------------------------------------------------------------- function esReal(cadena) { var myRegExp = new RegExp(REG_EXP_REAL); return myRegExp.test(cadena); } // ------------------------------------------------------------------------- // Recibe un número entero y devuelve true si esta en el formato correcto. // ------------------------------------------------------------------------- function esEntero(numero){ var objNotIntPattern=new RegExp("[^0-9-]"); var objIntPattern=new RegExp("^-[0-9]+$|^[0-9]+$"); return (!objNotIntPattern.test(numero) && objIntPattern.test(numero)); //var myRegExp = new RegExp(REG_EXP_ENTERO); //return regExp.test(numero); } // ------------------------------------------------------------------------- // Valida que el valor tenga los caracteres permitidos en los nombre propios // ------------------------------------------------------------------------- function esNombrePropio(texto){ var myRegExp = new RegExp(REG_EXP_NOMBPROP); return myRegExp.test(texto); } // ------------------------------------------------------------------------- // Valida que el valor tenga los caracteres permitidos en los nombre de // empresas // ------------------------------------------------------------------------- function esNombreEmpresa(texto){ var myRegExp = new RegExp(REG_EXP_NOMBEMP); return myRegExp.test(texto); } // ------------------------------------------------------------------------- // Valida que el texto tenga formato de e-mail. // ------------------------------------------------------------------------- function esEmail(texto){ var myRegExp = new RegExp(REG_EXP_EMAIL); return myRegExp.test(texto); } // ------------------------------------------------------------------------- // Valida que solo tenga los caracteres comunes en los número telefónicos // ------------------------------------------------------------------------- function esTelefono(texto){ var myRegExp = new RegExp(REG_EXP_TELEFONO); return myRegExp.test(texto); } // ------------------------------------------------------------------------- // esAno: Determina si es un formato válido de año yyyy // ------------------------------------------------------------------------- function esAno(Ano){ var myRegExp = new RegExp(REG_EXP_ANO); if (Ano.length != 4) { return false; }else{ if (!(myRegExp.test(Ano))) { return false; } } return true; } // ------------------------------------------------------------------------- // TieneComillas: Recibe una cadena y devuelve true si tiene comillas '/" // ------------------------------------------------------------------------- function TieneComillas(valor){ var sVal = new String(valor); var myRegExp = new RegExp(REG_EXP_COMILLAS); return myRegExp.test(sVal); } // ------------------------------------------------------------------------- // Compara fechas y con horas. f1 y f2 deben estar en formato dd/mm/yyyy; // h1 y h2 en formato AM/PM: 10:00 am/pm. // Valores de Retorno: // ------------------ // f2 ó h2 ó f1 ó h1 inválidas : -1 // f2+h2 > f1+h1 : 1 // f2+h2 < f1+h1 : 2 // f2+h2 = f1+h1 : 3 // hora_formato : 24H / 12H // ------------------------------------------------------------------------- function CompFechaHora(f1, f2, h1, h2, hora_formato){ var retVal = 0; if (!h1) var h1 = "00:00"; if (!h2) var h2 = "00:00"; if (!hora_formato) var hora_formato = "12H"; if (esFecha(f1) && esFecha(f2) && esHora(h1, hora_formato) && esHora(h2, hora_formato)){ if (hora_formato=="12H"){ var d1 = new Date(toMMDDYYYY(f1) + " " + Horato24H(h1)); var d2 = new Date(toMMDDYYYY(f2) + " " + Horato24H(h2)); }else{ var d1 = new Date(toMMDDYYYY(f1) + " " + h1); var d2 = new Date(toMMDDYYYY(f2) + " " + h2); } if (d1.toString()==d2.toString()){ retVal = 3; }else if (d2<=d1){ retVal = 2; }else if (d2>=d1){ retVal = 1; } }else{ retVal = -1; } return retVal; } // ------------------------------------------------------------------------- // esSeleccionado: // Determina si está seleccionado un OPTION del objeto SELECT. // Parámetros: // _id = Id del objeto select. // _Value = Valor por defecto del select. Este valor se usa para // saber si cambió. // Retorno: // Devuelve TRUE si el OPTION seleccionado en el SELECT es distinto al // valor por defecto (_Value); FALSE si es igual. // ------------------------------------------------------------------------- function esSeleccionado(_id, _value){ var retVal = true; var oSelect = document.getElementById(_id); var _valSel = oSelect.options[oSelect.selectedIndex].value if (_value==_valSel) retVal =false return (retVal); } // ------------------------------------------------------------------------- // esIndexCero: // Determina si el index del OPTION seleccionado es cero. // Parámetros: // _id = Id del objeto select. // Retorno: // Devuelve TRUE si el OPTION seleccionado en el SELECT es CERO; // de lo contrario FALSE // ------------------------------------------------------------------------- function esIndexCero(_id){ var retVal = false; var oSelect = document.getElementById(_id); if(oSelect.type=="select-one"){ if (oSelect.selectedIndex==0) retVal =true }else{ if (GlobalObj.isDebug) alert("Está intentando utilizar la función 'esIndexCero' en un objeto " + oSelect.type.toUpperCase() + ". Esta función solo se debe utilizar en los objetos de tipo SELECT"); } return (retVal); } // ************************************************************************* // Listado de functiones de conversión // ************************************************************************* // ------------------------------------------------------------------------- // Convierte la fecha de formato dd/mm/yyyy a mm/dd/yyyy // ------------------------------------------------------------------------- function toMMDDYYYY(fecha) { if (esFecha(fecha)){ var dd = fecha.substr(0,2); var mm = fecha.substr(3,2); var yy = fecha.substr(6,4); return(mm+"/"+dd+"/"+yy) }else{ alert("El formato de fecha para la conversión no es correcto."); return (fecha); } } // ------------------------------------------------------------------------- // Convierte la fecha de formato mm/dd/yyyy a dd/mm/yyyy // ------------------------------------------------------------------------- function toDDMMYYYY(fecha) { if (esFecha(fecha)){ var dd = fecha.substr(3,2); var mm = fecha.substr(0,2); var yy = fecha.substr(6,4); return(dd+"/"+mm+"/"+yy) }else{ alert("El formato de fecha para la conversión no es correcto."); return (fecha); } } // ------------------------------------------------------------------------- // Convierte la hora a formato 24H. // ------------------------------------------------------------------------- function Horato24H(hora) { if (esHora(hora, "12H")){ var hh = hora.substr(0,2); var mm = hora.substr(3,2); var tt = hora.substr(6,2); if (tt.toLowerCase() == 'pm'){ if (parseInt(hh)==12){ hh = "00";}else{hh = parseInt(hh)+12;} } return(hh+":"+mm) }else{ alert("El formato de hora es incorrecto."); return null; } } // ------------------------------------------------------------------------- // Convierte un número a formato moneda. // Ejemp: // Entrada: 122222.25 // Salida : Bs.122.222,25 // ------------------------------------------------------------------------- function FormatoMoneda(num, simbolo_moneda, separador_decimal, separador_miles) { if (!simbolo_moneda) simbolo_moneda = "Bs."; if (!separador_decimal) separador_decimal = ","; if (!separador_miles) separador_miles = "."; num = num.toString().replace(/\$|\,/g,''); if(isNaN(num)) num = "0"; sign = (num == (num = Math.abs(num))); num = Math.floor(num*100+0.50000000001); cents = num%100; num = Math.floor(num/100).toString(); if(cents<10) cents = "0" + cents; for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++) num = num.substring(0,num.length-(4*i+3))+ separador_miles + num.substring(num.length-(4*i+3)); return (((sign)?'':'-') + simbolo_moneda + num + separador_decimal + cents); } // ************************************************************************* // Listado de functiones utilitarias // ************************************************************************* // ------------------------------------------------------------------------- // Reemplaza coincidencias de una cadena por otra // ------------------------------------------------------------------------- function Reemplaza(origen, coincidencia, reemplazo, case_sensitive){ var sVal = new String(origen); var sRegExp = coincidencia; if (!case_sensitive) var myRegExp = new RegExp(sRegExp, "gi"); else var myRegExp = new RegExp(sRegExp, "g"); var retVal = sVal.replace(myRegExp, reemplazo); return retVal; } // ------------------------------------------------------------------------- // Elimina los espacios en blanco a ambos extremos de una cadena // ------------------------------------------------------------------------- function Trim(cadena) { cadena=cadena.replace(/^\s*(.*)/, "$1"); cadena=cadena.replace(/(.*?)\s*$/, "$1"); return cadena; } // ------------------------------------------------------------------------- // Elimina los espacios en blanco a la izquierda de una cadena // ------------------------------------------------------------------------- function LTrim(cadena) { cadena=cadena.replace(/^\s*(.*)/, "$1"); return cadena; } // ------------------------------------------------------------------------- // Elimina los espacios en blanco a la derecha de una cadena // ------------------------------------------------------------------------- function RTrim(cadena) { cadena=cadena.replace(/(.*?)\s*$/, "$1"); return cadena; }