/*
  -------------------------------------------------------------------------
	                    JavaScript Form Validator 
                                Version 2.0.2
	Copyright 2003 JavaScript-coder.com. All rights reserved.
	You use this script in your Web pages, provided these opening credit
    lines are kept intact.
	The Form validation script is distributed free from JavaScript-Coder.com

	You may please add a link to JavaScript-Coder.com, 
	making it easy for others to find this script.
	Checkout the Give a link and Get a link page:
	http://www.javascript-coder.com/links/how-to-link.php

    You may not reprint or redistribute this code without permission from 
    JavaScript-Coder.com.
	
	JavaScript Coder
	It precisely codes what you imagine!
	Grab your copy here:
		http://www.javascript-coder.com/
    -------------------------------------------------------------------------  
*/

//--------------------------------------------------------------------------

// these illegal characters will be replaced in the customvalidation section
// (they are defined as regular expressions; the g is needed for a global replace)

var num_illegal_chars = 3;

var illegal_chars = new Array(num_illegal_chars);

illegal_chars[0] = /'/g;
illegal_chars[1] = /#/g;
illegal_chars[2] = /@/g;

//--------------------------------------------------------------------------

var num_regexp_validation = 4;

var regexp_validation = new Array(num_regexp_validation);

// illegal characters (@ sign, "http")
regexp_validation[0] = "(\%40)|(@)|(http)|(href)|(url=)";

// cross-site scripting attack - any angle bracket pair
regexp_validation[1] = "((\%3C)|<)[^\n]+((\%3E)|>)";

// sql injection attack (single quote, double dash, # sign)
regexp_validation[2] = "(\%27)|(\')|(\-\-)|(\%23)|(#)";

// sql injection attack (execute stored procedure)
regexp_validation[3] = "(sp_)|(xp_)";

//--------------------------------------------------------------------------

function Validator(frmname)
{
	this.formobj = document.forms[frmname];
	
	if(!this.formobj)
	{
		alert("BUG: couldnot get Form object " + frmname);
		return;
	}
	
	if(this.formobj.onsubmit)
	{
		this.formobj.old_onsubmit = this.formobj.onsubmit;
		this.formobj.onsubmit = null;
	}
	else
	{
		this.formobj.old_onsubmit = null;
	}
	
	this.formobj.onsubmit = form_submit_handler;
	this.addValidation = add_validation;
	this.setAddnlValidationFunction = set_addnl_vfunction;
	this.clearAllValidations = clear_all_validations;
}

//--------------------------------------------------------------------------

function set_addnl_vfunction(functionname)
{
	this.formobj.addnlvalidation = functionname;
}

//--------------------------------------------------------------------------

function clear_all_validations()
{
	for(var itr = 0; itr < this.formobj.elements.length; itr++)
	{
		this.formobj.elements[itr].validationset = null;
	}
}

//--------------------------------------------------------------------------

function form_submit_handler()
{
	for(var itr = 0; itr < this.elements.length; itr++)
	{
		if(this.elements[itr].validationset && !this.elements[itr].validationset.validate())
		{
			return false;
		}
	}
	
	if(this.addnlvalidation)
	{
		str = " var ret = " + this.addnlvalidation + "()";
		eval(str);
		if(!ret) return ret;
	}
	
	return true;
}

//--------------------------------------------------------------------------

function add_validation(itemname,descriptor,errstr)
{
    if(!this.formobj)
	{
		alert("BUG: the form object is not set properly");
		return;
	}
	
	var itemobj = this.formobj[itemname];
	if(!itemobj)
	{
		alert("BUG: Could not get the input object named: " + itemname);
		return;
	}
	
	if(!itemobj.validationset)
	{
		itemobj.validationset = new ValidationSet(itemobj);
	}
	
    itemobj.validationset.add(descriptor,errstr);
}

//--------------------------------------------------------------------------

function ValidationDesc(inputitem,desc,error)
{
	this.desc = desc;
	this.error = error;
	this.itemobj = inputitem;
	this.validate = vdesc_validate;
}

//--------------------------------------------------------------------------

function vdesc_validate()
{
	if(!V2validateData(this.desc, this.itemobj, this.error))
	{
		this.itemobj.focus();
		return false;
	}
	return true;
}

//--------------------------------------------------------------------------

function ValidationSet(inputitem)
{
    this.vSet = new Array();
	this.add = add_validationdesc;
	this.validate = vset_validate;
	this.itemobj = inputitem;
}

//--------------------------------------------------------------------------

function add_validationdesc(desc,error)
{
	this.vSet[this.vSet.length]= new ValidationDesc(this.itemobj,desc,error);
}

//--------------------------------------------------------------------------

function vset_validate()
{
	for(var itr=0;itr<this.vSet.length;itr++)
	{
	  if(!this.vSet[itr].validate())
	    {
	      return false;
	    }
	}
	return true;
}

//--------------------------------------------------------------------------

function validateEmailv2(email)
{

// a very simple email validation checking. 
// you can add more complex email checking if it helps 

    if(email.length <= 0)
	{
		return true;
	}
	
    var splitted = email.match("^(.+)@(.+)$");
    
    if(splitted == null) return false;
    
    if(splitted[1] != null )
    {
		var regexp_user=/^\"?[\w-_\.]*\"?$/;
		if(splitted[1].match(regexp_user) == null) return false;
    }
    
    if(splitted[2] != null)
    {
		var regexp_domain=/^[\w-\.]*\.[A-Za-z]{2,4}$/;
      
		if(splitted[2].match(regexp_domain) == null) 
		{
			var regexp_ip =/^\[\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\]$/;
			if(splitted[2].match(regexp_ip) == null) return false;
		}
      
		return true;
    }
    
	return false;
}

//--------------------------------------------------------------------------

function V2validateData(strValidateStr,objValue,strError) 
{ 
    var epos = strValidateStr.search("=");
    var command  = "";
    var cmdvalue = "";
    
    if(epos >= 0)
    {
		command  = strValidateStr.substring(0,epos);
		cmdvalue = strValidateStr.substr(epos+1);
    } 
    else 
    { 
		command = strValidateStr; 
    }
    
    switch(command) 
    { 
        
        //----------------------------------------------------------------------------------
        
		case "req": 
		case "required": 
        {
        
			if(eval(objValue.value.length) == 0) 
			{ 
			   if(!strError || strError.length == 0) 
			   { 
					strError = objValue.name + " : Required Field"; 
			   } 
			   alert(strError); 
			   return false; 
			} 
			break;
           
        }//case required
        
        //----------------------------------------------------------------------------------
        
        case "maxlength": 
        case "maxlen": 
        { 
        
            if(eval(objValue.value.length) >  eval(cmdvalue)) 
            { 
              if(!strError || strError.length == 0) 
              { 
                strError = objValue.name + " : "+cmdvalue+" characters maximum "; 
              }
              alert(strError + "\n[Current length = " + objValue.value.length + " ]"); 
              return false; 
            }
            break;
             
        }//case maxlen 
        
        //----------------------------------------------------------------------------------
        
        case "minlength": 
        case "minlen": 
        { 
        
            if(eval(objValue.value.length) <  eval(cmdvalue)) 
            { 
              if(!strError || strError.length == 0) 
              { 
                strError = objValue.name + " : " + cmdvalue + " characters minimum  "; 
              }
              alert(strError + "\n[Current length = " + objValue.value.length + " ]"); 
              return false;
            }
            break; 
             
         }//case minlen 
        
        //----------------------------------------------------------------------------------
        
        case "alnum": 
        case "alphanumeric": 
        {
        
            var charpos = objValue.value.search("[^A-Za-z0-9]"); 
              
            if(objValue.value.length > 0 &&  charpos >= 0) 
            { 
              if(!strError || strError.length == 0) 
              { 
                strError = objValue.name+": Only alpha-numeric characters allowed "; 
              }
              alert(strError + "\n [Error character position " + eval(charpos+1)+"]"); 
              return false; 
            }
            break;
              
        }//case alphanumeric 
        
        //----------------------------------------------------------------------------------
        
        case "num": 
        case "numeric": 
        { 
        
            var charpos = objValue.value.search("[^0-9]");
              
            if(objValue.value.length > 0 &&  charpos >= 0) 
            { 
              if(!strError || strError.length == 0) 
              { 
                strError = objValue.name+": Only digits allowed "; 
              }
              alert(strError + "\n [Error character position " + eval(charpos+1)+"]"); 
              return false; 
            }
            break;
                           
        }//numeric 
        
        //----------------------------------------------------------------------------------
        
        case "alphabetic": 
        case "alpha": 
        {
        
			var charpos = objValue.value.search("[^A-Za-z]");
			      
			if(objValue.value.length > 0 &&  charpos >= 0)
			{ 
			  if(!strError || strError.length == 0) 
			  { 
			    strError = objValue.name+": Only alphabetic characters allowed "; 
			  }
			  alert(strError + "\n [Error character position " + eval(charpos+1)+"]"); 
			  return false; 
			}
			break;
              
        }//alpha 
        
        //----------------------------------------------------------------------------------
        
		case "alnumhyphen":
		{
		
            var charpos = objValue.value.search("[^A-Za-z0-9\-_]"); 
              
            if(objValue.value.length > 0 &&  charpos >= 0) 
            { 
              if(!strError || strError.length == 0) 
              { 
                strError = objValue.name+": characters allowed are A-Z,a-z,0-9,- and _"; 
              }
              alert(strError + "\n [Error character position " + eval(charpos+1)+"]"); 
              return false; 
            }
			break;
			
		}
        
        //----------------------------------------------------------------------------------
        
        case "email": 
        { 
        
            if(!validateEmailv2(objValue.value)) 
            { 
              if(!strError || strError.length == 0) 
              { 
                 strError = objValue.name+": Enter a valid Email address "; 
              }
              alert(strError); 
              return false; 
            }
            break; 
           
        }//case email 
        
        //----------------------------------------------------------------------------------
        
        case "lt": 
        case "lessthan": 
        { 
        
            if(isNaN(objValue.value)) 
            { 
              alert(objValue.name + ": Should be a number "); 
              return false; 
            }
            
            if(eval(objValue.value) >=  eval(cmdvalue)) 
            { 
              if(!strError || strError.length == 0) 
              { 
                strError = objValue.name + " : value should be less than " + cmdvalue; 
              }
              alert(strError); 
              return false;                 
            }
            break; 
            
        }//case lessthan 
        
        //----------------------------------------------------------------------------------
        
        case "gt": 
        case "greaterthan": 
        { 
			
            if(isNaN(objValue.value)) 
            { 
              alert(objValue.name + ": Should be a number "); 
              return false; 
            }
            
            if(eval(objValue.value) <=  eval(cmdvalue)) 
            { 
               if(!strError || strError.length == 0) 
               { 
                 strError = objValue.name + " : value should be greater than " + cmdvalue; 
               }
               alert(strError); 
               return false;                 
            }
            break; 
            
        }//case greaterthan 
        
        //----------------------------------------------------------------------------------
        // if match, then accept
        
        case "regexp": 
        { 
			//alert(objValue.value);
			//alert(cmdvalue);
			
			if(objValue.value.length > 0)
			{
			    if(!objValue.value.match(cmdvalue))
			    {
					//alert("match");
					
					if(!strError || strError.length == 0)
					{
					  strError = objValue.name + ": Invalid characters found ";
					}
					alert(strError);
					return false;
			    }
			}
			break;
           
        }//case regexp 
        
        //----------------------------------------------------------------------------------
        // if match, then reject
        
        case "badregexp": 
        { 
			//alert(objValue.value);
			//alert(cmdvalue);
			
			if(objValue.value.length > 0)
			{
			    if(objValue.value.match(cmdvalue))
			    {
					//alert("match");
					
					if(!strError || strError.length == 0)
					{
					  strError = objValue.name + ": Invalid characters found ";
					}
					alert(strError);
					return false;
			    }
			}
			break;
           
        }//case badregexp 
        
        //----------------------------------------------------------------------------------
        
        case "dontselect": 
        { 
        
            if(objValue.selectedIndex == null) 
            { 
              alert("BUG: dontselect command for non-select Item"); 
              return false; 
            } 
            
            if(objValue.selectedIndex == eval(cmdvalue)) 
            { 
				if(!strError || strError.length ==0) 
				{ 
					strError = objValue.name + ": Please Select one option "; 
				}
				alert(strError); 
				return false;
             } 
             break;
             
        }//case dontselect 
        
        //----------------------------------------------------------------------------------
        
        case "customvalidation": 
        { 
			// replace illegal characters
			
			var curr_val = objValue.value;

			var x = 0;
				
			// loop through the array of illegal characters defined above
				
			for (x = 0; x < num_illegal_chars; x++)
			{
				objValue.value = curr_val.replace(illegal_chars[x], "");
				curr_val = objValue.value;
			}		
			
			//--------------------------------------------------------------------

			if(objValue.value.length > 0)
			{					
				// loop through the array of regular expressions defined above
				
				for (x = 0; x < num_regexp_validation; x++)
				{
					//alert(objValue.value);
					//alert(regexp_validation[x]);
					
					// reject if value matches the regular expression
					
					if(objValue.value.match(regexp_validation[x]))
					{
						//alert("match");

						if(!strError || strError.length == 0)
						{
						  strError = objValue.name + ": Invalid characters found ";
						}
						alert(strError);
						return false;
					}
				}
			}
			break;
              
        }//case customvalidation 
        
        //----------------------------------------------------------------------------------
        
    }//switch 
    
    return true; 
}

//--------------------------------------------------------------------------

/*
	Copyright 2003 JavaScript-coder.com. All rights reserved.
*/