/* FILE HEADER **************************************************
** JS Validate
** Author: Karl Seguin, Timo Haberkern
** Homepage: http://jsval.berlios.de/
** Version: 0.4.0
** Copyright 2003, 2004 Karl Seguin

    This file is part of JS Validate.

    JS Validate is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    JS Validate is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with JS Validate; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**

* MODIFICACIONES:
Le agregue la funcion IsAlphanumeric y el regexp=alfanumerico (Paola, mayo'06)

** END HEADER ***************************************************/

function validateCompleteForm (objForm, strErrorClass) {
    return _validateInternal(objForm, strErrorClass, 0);
}

function validateStandard (objForm, strErrorClass) {
    return _validateInternal(objForm, strErrorClass, 1);
}
   
/***************************************************************
** Internal functions
*****************************************************************/
function _validateInternal(form, strErrorClass, nErrorThrowType){
   var strErrorMessage = ""; var objFirstError = null;
   if (nErrorThrowType == 0) strErrorMessage = (form.err) ? form.err : "Por favor, ingrese valores o valores corectos para los siguientes campos:\n\n";
  
   var fields = _GenerateFormFields(form);
   for (var i = 0; i < fields.length; ++i){
      var field = fields[i];
      field.ResetClass();
      if (!field.IsValid()){
        field.SetClass(strErrorClass);
        if (nErrorThrowType == 1) {        
            _throwError(field);
            return false;
        }else{
            if (objFirstError == null){
               objFirstError = field;
            }
            strErrorMessage = _handleError (field, strErrorMessage);
            bError = true;
        }
      }
   }
   if (objFirstError != null) {
      alert(strErrorMessage);
      objFirstError.element.focus();
      return false;
  }
  return true;
 }
 
 function _GenerateFormFields(form){
   var arr = new Array();
   for (var i = 0; i < form.length; ++i){
      var element = form.elements[i];
      var index = _getElementIndex(arr,element);
      //if it doesn't already exist, add it to our array, else merge the change
      if (index == -1){
         arr[arr.length] = new Field(element, form);
      }else{                
         arr[index].Merge(element)
      }
   }
   return arr;
}
function _getElementIndex(arr, element){
   var elementName = element.name.toLowerCase();
   for (var i = 0; i < arr.length; ++i){
      if (arr[i].element.name.toLowerCase() == elementName){
         return i;
      }
   }
   return -1;
}

/***************************************************************
** Field Class
*****************************************************************/
function Field(element, form){
   this.type = element.type;
   this.element = element;
   this.exclude = element.exclude || element.getAttribute('exclude');
   this.err = element.err || element.getAttribute('err');
   this.required = _parseBoolean(element.required || element.getAttribute('required'));
   switch (this.type){
      case "textarea":
      case "password":
      case "file":
      case "text":
         this.value = element.value;
         this.minLength = element.minlength || element.getAttribute('minlength');
         this.maxLength = element.maxlength || element.getAttribute('maxlength');
         this.regexp = element.regexp || element.getAttribute('regexp');
         this.minValue = element.minvalue || element.getAttribute('minvalue');
         this.maxValue = element.maxvalue || element.getAttribute('maxvalue');
         break;
      case "select-one":
      case "select-multiple":
         this.values = new Array();
         for (var i = 0; i < element.options.length; ++i){
            if (element.options[i].selected && (!this.exclude || element.options[i].value != this.exclude)){
               this.values[this.values.length] = element.options[i].value;
            }
         }
         this.min = element.min || element.getAttribute('min');
         this.max = element.max || element.getAttribute('max');         
         break;
      case "checkbox":
         this.min = element.min || element.getAttribute('min');
         this.max = element.max || element.getAttribute('max');   
         //no break, let it fall through to radio
      case "radio":
          this.required = _parseBoolean(this.required || element.getAttribute('required'));
          this.values = new Array();
          if (element.checked){
             this.values[0] = element.value;
          }
          this.elements = new Array();
          this.elements[0] = element;
          break;
   }
}
Field.prototype.Merge = function(element){
   //never negate a require field
   var required = _parseBoolean(element.getAttribute('required'));
   if (required){
      this.required = true;
   }
   //all other cases (except required) we only add if there isn't already a value (first come first served)
   if (!this.err){
      this.err = element.getAttribute('err');
   }
   if (!this.max){
      this.max = element.getAttribute('max');
   }
   if (!this.min){
      this.min = element.getAttribute('min');
   }
   if (element.checked){
      this.values[this.values.length] = element.value;   
   }
   this.elements[this.elements.length] = element;
}
Field.prototype.IsValid = function(){
  switch (this.type){
      case "textarea":
      case "password":
      case "file":
      case "text":
         return this._ValidateText();
      case "select-one":
      case "select-multiple":          
      case "radio":        
      case "checkbox":      
         return this._ValidateGroup();
      default:
         return true;
   }
}
Field.prototype.SetClass = function(newClassName){
   if (this.elements){
      for (var i = 0; i < this.elements.length; ++i){
         this.elements[i].oldClassName = this.elements[i].className;
         this.elements[i].className = newClassName;   
      }
   }else{
      this.element.oldClassName = this.element.className;
      this.element.className = newClassName;
   }  
}
Field.prototype.ResetClass = function(){
   if (this.elements){
      for (var i = 0; i < this.elements.length; ++i){
         this.elements[i].className = this.elements[i].oldClassName;
      }
   }else{
      this.element.className = this.element.oldClassName;
   }  

}
Field.prototype._ValidateText = function(){
   //required value is empty
   if (this.required && !this.value){
      return false;
   }
   //value less than minlength
   if (this.value && (this.minLength && this.value.length < this.minLength)){
      return false;
   }
   //value is more than maxlength
   if (this.value && (this.maxLength && this.value.length > this.maxLength)){
      return false;
   }

   //value fails regular expression 
   if (this.regexp && !_checkRegExp(this.regexp, this.value)){
      //the field isn't required, but there is a value 
      if (!this.required && this.value){
         return false;
      }
      if (this.required){
         return false;
      }
   } 

   //check against minvalue and maxvalue
   if (this.required){
      var fValue = parseFloat(this.value);
      
      //alert (fValue+","+this.maxValue);   NO MUESTRO EL ERROR PORQUE NO ME GUSTA
      if ((this.minValue || this.maxValue) && isNaN(fValue)){
         return false;
      }
      if (fValue < this.minValue){
         return false;
      }
      if (fValue > this.maxValue){
         return false;
      }
   }   
   return true;
}
Field.prototype._ValidateGroup = function(){
   if (this.required && this.values.length == 0){
      return false;
   }
   if (this.required && this.min && this.min > this.values.length){
      return false;
   }
   if (this.required && this.max && this.max < this.values.length){
      return false;
   }   
   return true;
}

function _handleError (field, strErrorMessage) {
   var obj = field.element;
   strErrorMessage = strErrorMessage + ((obj.id) ? obj.id : obj.name) + "\n";    
   return strErrorMessage;
}

function _throwError(field){
   var obj = field.element;
   switch (field.type){
      case "text":
      case "password":
      case "textarea":
         alert(_getError(field, "ingrese"));
         obj.focus();
         break;
      case "select-one":
      case "select-multiple":      
      case "radio":  
      case "checkbox":       
         alert(_getError(field, "select"));
         break;
      }
}

function _getError(field, str){
   var obj = field.element;
   return (field.err) ? field.err : "Por favor " + str + " un \"" + ((obj.id) ? obj.id : obj.name) + "\" válido";
}

function _parseBoolean(value){
   return !(!value || value == 0 || value == "0" || value == "false");
}

function _checkRegExp(regx, value){
  switch (regx){
  case "email":
    return ((/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,5})+$/).test(value));
  case "tel":
    return ((/^1?[\- ]?\(?\d{3}\)?[\- ]?\d{3}[\- ]?\d{4}$/).test(value));
  case "pc":
    return ((/^[a-z]\d[a-z] ?\d[a-z]\d$/i).test(value));
  case "zip":
    return ((/^\d{5}$/).test(value));
  case "money":
    return ((/^\d+([\.]\d\d)?$/).test(value));
  case "creditcard":
    return (!isNaN(value));   
  case "alfanumerico":
    return (isAlphanumeric(value));   
  case "postalzip":
    if(value.length == 6 || value.length == 7)
      return((/^[a-zA-Z]\d[a-zA-Z] ?\d[a-zA-Z]\d$/).test(value));
    if(value.length == 5 || value.length == 10)
      return((/^\d{5}(\-\d{4})?$/).test(value));
    break;
  default:
    return (regx.test(value));

  }
}


function isAlphanumeric (s)
// s tiene solo letras, numeros o espacios en blanco
{   var i;
    if (isEmpty(s)) 
       if (isAlphanumeric.arguments.length == 1) return defaultEmptyOK;
       else return (isAlphanumeric.arguments[1] == true);
    for (i = 0; i < s.length; i++)
    {   
        var c = s.charAt(i);
        if (! (isLetter(c) || isDigit(c) ) )
        return false;
    }
    return true;
}


/* scroll en barra de estado 
   Cuando lo quiera sacar, solo hay que comentar esta parte

 
var speed = 150 
var pause = 100
var timerID = null
var bannerRunning = false
var ar = new Array()
ar[0] = ">>>> Estás usando TEST ON LINE.. la herramienta más facil de evaluar en poco tiempo"
ar[1] = " Si no sabes usarlo, debes elegir la opción Ayuda ....."
ar[2] = "..... allí encontrarás una breve descripción de su uso."

var currentMessage = 0
var offset = 0

function stopBanner() {
if (bannerRunning)
clearTimeout(timerID)
bannerRunning = false
}

function startBanner() {
stopBanner()
showBanner()
}

function showBanner() {
var text = ar[currentMessage]
if (offset < text.length) {
if (text.charAt(offset) == " ")
offset++ 
var partialMessage = text.substring(0, offset + 1) 
window.status = partialMessage
offset++ // IE sometimes has trouble with "++offset"
timerID = setTimeout("showBanner()", speed)
bannerRunning = true
} else {
offset = 0
currentMessage++
if (currentMessage == ar.length)
currentMessage = 0
timerID = setTimeout("showBanner()", pause)
bannerRunning = true
}
}
startBanner();
*/