//////////////////////////////////////////////////////////////////////////////////////
//
// validacja 1.0.1
//
// modyfikacje:
//   kiedys tam [wgr]: pierwa wersja
//   14.09.05 [tno]:   + nowy sposób konstruowania komunikatu o błędzie
//                     + obsługa minimalnej długości podawanego hasła
// 
// TODO:
//   - dorobic obsluge wielu formularzy
//   - obsluga bledow date i datefuture
//
//
////////////////////////////////////////////////////////////////////////////////////

var Params = new Array();

// parametry walidacji
Params.errorBG = "#ffa468"; // kolor tla blednego pola #FDA835
Params.clearBG = "#FFFFFF"; // kolor tla poprawnego pola
Params.passwordLenght = 6;

// komunikaty
Params.defaultErrorMessage = "W formularzu wystąpiły błędy w polach zaznaczonych kolorem:\n";
Params.notEmptyErrorMessage = "\n- Wymagane pole nie zostało wypełnione";
Params.mustCheckedErrorMessage = "\n- Wymagane pole nie zostało zaznaczone";
Params.mustOneCheckedErrorMessage = "\n- Jedno z grupy wymaganych pól nie zostało zaznaczone";
Params.passwordLenghtErrorMessage = "\n- Hasło powinno mieć co najmniej "+Params.passwordLenght+" znaków";
Params.passwordRepeatErrorMessage = "\n- Hasło i powtórzone hasło nie zgadzają się lub któreś z nich nie zostało podane.";
Params.floatErrorMessage = "\n- Wpisana wartość nie jest liczbą";
Params.emailErrorMessage = "\n- Podany adres nie jest prawidłowym adresem E-Mail";
Params.regonErrorMessage = "\n- Podany REGON jest nieprawidłowy";
Params.nipErrorMessage = "\n- Podany NIP jest nieprawidłowy";
Params.zipErrorMessage = "\n- Podany kod pocztowy jest nieprawidłowy";
Params.dateErrorMessage = "\n- Wpisana data jest nieprawidłowa. Poprawny format daty to np. 2004-11-26";
Params.dateFutureErrorMessage = "\n- Wpisana data jest wcześniejsza niż wymagana";

var correct;             
var errorMessage;
var errorArray = {};

//var valArray = new Array();

// sprawdza wersje przegladarki
function checkBrowser()
{
     if(document.layers)
     {
          return "NN4";
     }
     if(document.all)
     {
          return "IE";
     }
     if(!document.all && document.getElementById)
     {
          return "NN6";
     }
}


function GetLayer(layer)
{
     var ReturnLayer = null;
     if(navigator.appName == 'Netscape')
     {       
          if(parseInt(navigator.appVersion) == 5)
               ReturnLayer = document.getElementById(layer);
          else
               eval('ReturnLayer = document.' + layer + ';');
     }
     else
     {
          eval('ReturnLayer = document.all.' + layer + ';');
     }
     return ReturnLayer; 
}


function validate(formName)
{
     var element;
     var params;
     var groupChecked = false;
     var lastGroupName = "";
     var currentGroupName = "";
     var mustOneCheck = false;

     errorArray["NotEmpty"]=false;
     errorArray["MustChecked"]=false;
     errorArray["MustOneChecked"]=false;
     errorArray["PasswordRepeat"]=false;
     errorArray["PasswordLenght"]=false;
     errorArray["Float"]=false;
     errorArray["EMail"]=false;
     errorArray["REGON"]=false;
     errorArray["NIP"]=false;
     errorArray["ZIP"]=false;
     errorArray["Date"]=false;
     errorArray["DateFuture"]=false;

   correct = true;             
     errorMessage = Params.defaultErrorMessage;

     formElements = document.forms[formName].elements.length;

     for (k=0; k<formElements; k++)
     {
          element = document.forms[formName].elements[k]; 
          strValParams = "";
          if(typeof(element.attributes["val"]) == "object")
          {
               strValParams = element.attributes["val"].value; 
          }

          params=null;
          if(strValParams!="")
          {
               // valType = element.id; 
               data = strValParams.split(";")
               valType = data[0]; 
               if(data.length>1) params = data[1].split(":");
          }
          else valType = strValParams; 
      
          //alert(valType);
      
          fieldValue = element.value;
          fieldFlag = element.flag;
          
          if (typeof(fieldFlag)=='undefined')
          {
               fieldFlag=1;         
          }

          // znalazlem zadanie wywolania zewnetrznej funkcji validujacej
          if(params && params[0] == "@F")
          {
             
               evalStr = "extFuncResult = " + params[1] + "();";
               eval(evalStr);
         
               if(typeof(extFuncResult) == "undefined")
                    extFuncResult = false;
             
               if(extFuncResult == false)
               {
                    valType = "NotValidate";
                    correct = false;
                    markField(element);
               }
               else
               {
                    unmarkField(element);
               }
          }
          
         switch(valType)
         {
              case "EMail":
                    bool=false;
                    bool = checkMail(fieldValue, fieldFlag);
                    tmp = correct;
                    correct = (tmp && bool);
                    if (bool==false)
                    {
                         markField(element);
                         errorArray["EMail"]=true;
                    }
                    else
                         unmarkField(element);
                    
            break;
         case "MustChecked":
            if(params.length!=null)
            {
               bool=element.checked;
               tmp = correct;
               correct = (tmp && bool);
               if(bool==false)
                         {
                  GetLayer(params[0]).style.background=Params.errorBG;
                              errorArray["MustChecked"]=true;
                         }
               else
                  GetLayer(params[0]).style.background='none';
            }
            break;
         case "MustOneChecked":
            if(params.length!=null)
            {
               mustOneCheck = true;
               // sprawdze czy sa elementy z tej grupy
               currentGroupName = params[0];
               if(lastGroupName != currentGroupName)
               {
                  lastGroupName = currentGroupName
                  groupChecked = false;
               }
               groupChecked = (element.checked | groupChecked);
               tmp = correct;
               if(groupChecked)
                  GetLayer(params[0]).style.background='none';
               else
                 {
                  GetLayer(params[0]).style.background=Params.errorBG;
                  errorArray["MustOneChecked"]=true;
                 }
            }
            break;
            case "NotEmpty":
                   bool=false;
                   bool = checkFilled(fieldValue);   
              tmp = correct;
              correct = (tmp && bool);
              if (bool==false)
                    {
                 markField(element);
                         errorArray["NotEmpty"]=true;
                    }
              else
                 unmarkField(element);
              break;  
           case "Date":
                bool="";
                    var check;
            if(fieldValue!="") 
               check = true;
                    else
                    {
                         if(params!=null && params[0]=="notrequired") check=false;
                         else check=true;
                    }
                    if(check==true)
                    {
                         bool = checkDate(fieldValue, fieldFlag);
                          tmp = correct;
                          correct = (tmp && bool); 
                          if (bool==false)
               {
                               markField(element);
                            errorArray["Date"]=true;
               }
                          else
                                unmarkField(element);
                    }
                    break;
               case "DateFuture":
                bool="";
                    var check;
                    if(fieldValue!="") check = true;
                    else
                    {
                         if(params!=null && params[0]=="notrequired") check=false;
                         else check=true;
                    }
                    if(check==true)
                    {
               isDate = checkDate(fieldValue, fieldFlag);
               isFuture = isFromFuture(fieldValue);
               bool = isDate && isFuture;
                          tmp = correct;
                          correct = (tmp && bool); 
                          if (bool==false)
               {
                               markField(element);
                            if(!isDate) errorArray["Date"]=true;
                            if(isDate && !isFuture) errorArray["DateFuture"]=true;
               }
                          else
                                unmarkField(element);
                    }
                    break;
               case "REGON":
                    var check;
                    if(fieldValue!="") check = true;
                    else
                    {
                         if(params!=null && params[0]=="notrequired") check=false;
                         else check=true;
                    }
                    if(check==true)
                    {
                         bool = checkREGON(fieldValue, fieldFlag);
                         tmp = correct;
                         correct = (tmp && bool);
                         if (bool==false)
                         {
                              markField(element);
                              errorArray["REGON"]=true;
                         }
                         else
                              unmarkField(element);
                    }
                    break;
               case "NIP":
                    var check;
                    if(fieldValue!="") check = true;
                    else
                    {
                         if(params!=null && params[0]=="notrequired") check=false;
                         else check=true;
                    }
                    if(check==true)
                    {
                         bool = checkNIP(fieldValue, fieldFlag);
                         tmp = correct;
                         correct = (tmp && bool);
                         if (bool==false)
               {
                              markField(element);
                              errorArray["NIP"]=true;
               }
                         else
                              unmarkField(element);
                    }
                    break;
               case "Float":
                    var check;
                    if(fieldValue!="") check = true;
                    else
                    {
                         if(params!=null && params[0]=="notrequired") check=false;
                         else check=true;
                    }
                    if(check==true)
                    {
                         bool = checkFloat(fieldValue, fieldFlag);
                         tmp = correct;
                         correct = (tmp && bool);
                         if (bool==false)
                         {
                              markField(element);
                              errorArray["Float"]=true;
                         }
                       else
                              unmarkField(element);
                    }      
                    break;
               case "ZIP":
                    bool = checkZIP(fieldValue, fieldFlag);
                    tmp = correct;
                    correct = (tmp && bool);
                    if (bool==false)
            {  
                         markField(element);
                         errorArray["ZIP"]=true;
            }
                    else
                         unmarkField(element);
                    break;
               case "Password":
                    // tu trzeba troszke zamieszac i pobrac od razu wartos drugiego pola
                    Pass = fieldValue;
                    rePass = document.forms[formName].elements[k+1].value;
                    
                    bool = checkPass(Pass, rePass ,fieldFlag);
                    tmp = correct;
                    correct = (tmp && bool);
                    if (bool==false)
                    {
                         markField(element);
               markField(document.forms[formName].elements[k+1]);
                    }
                    else
                    {
                         unmarkField(element);
               unmarkField(document.forms[formName].elements[k+1]);
                    }
                    break;
         }
   }
    
   if ((correct==true) && (!mustOneCheck || (mustOneCheck && groupChecked)) )
   {
      document.forms[formName].submit();
        return true;
   }     
   else
   {
          if(errorArray["NotEmpty"]==true) errorMessage += Params.notEmptyErrorMessage;
          if(errorArray["MustChecked"]==true) errorMessage += Params.mustCheckedErrorMessage;
          if(errorArray["MustOneChecked"]==true) errorMessage += Params.mustOneCheckedErrorMessage;
          if(errorArray["PasswordRepeat"]==true) errorMessage += Params.passwordRepeatErrorMessage;
          if(errorArray["PasswordLenght"]==true) errorMessage += Params.passwordLenghtErrorMessage;
          if(errorArray["Float"]==true) errorMessage += Params.floatErrorMessage;
          if(errorArray["EMail"]==true) errorMessage += Params.emailErrorMessage;
          if(errorArray["REGON"]==true) errorMessage += Params.regonErrorMessage;
          if(errorArray["NIP"]==true) errorMessage += Params.nipErrorMessage;
          if(errorArray["ZIP"]==true) errorMessage += Params.zipErrorMessage;
          if(errorArray["Date"]==true) errorMessage += Params.dateErrorMessage;
          if(errorArray["DateFuture"]==true) errorMessage += Params.dateFutureErrorMessage;
        alert (errorMessage);
        return false;
   }     
}
  
 
//////////////////////////////////////////////////////////////////////  
function checkMail(str, flag)
{
   if (flag==1 || str!="")
   {
        var email=/^[A-Za-z0-9]+([_\.-][A-Za-z0-9]+)*@[A-Za-z0-9]+([_\.-][A-Za-z0-9]+)*\.([A-Za-z]){2,4}$/i;
          return (email.test(str));           
     }
     else
     {
               return true;
       }
}
  
function checkZIP(str, flag)
{
   if (flag==1 || str!="")
   {
        var ZIP=/^[0-9]{2}[-]{1}[0-9]{3}$/i;
          return (ZIP.test(str));           
     }
     else
     {
        return true;
       }
}
   
  
function checkFilled(str)
{
   var num = /\s/;
   while(num.test(str))
   {
      str = str.replace(num, "");
   }   
   if (str=="")
   {
      //errorMessage += "nie\n";
      return false;
   }
   else
   {
        return true;      
   }
}

function isFromFuture(strDate)
{
   // dane wejsciowe
   strSeparator = "-";
   arrDate = strDate.split(strSeparator);
    
   intChkYear   = parseInt(arrDate[0]*1);
   intChkMonth  = parseInt(arrDate[1]*1);
   intChkDay    = parseInt(arrDate[2]*1);
        
   // dzisiejsze dane
   objNow = new Date();
   intNowDay    = parseInt(objNow.getDate());
   intNowMonth  = parseInt(objNow.getMonth())+1;
   intNowYear   = parseInt(objNow.getFullYear());                                  

   //alert(intNowDay + "." + intNowMonth+ "." +intNowYear);
     //alert(intChkDay + "." + intChkMonth+ "." +intChkYear);
   if(intChkYear > intNowYear)
   {
      return true;
   } 
   else if(intChkYear < intNowYear)
   {
      return false;
   }  
   else      if(intChkMonth > intNowMonth)
   {
      return true;
   } 
   else if(intChkMonth < intNowMonth)
   {
      return false;
   }
   else  if(intChkDay >= intNowDay)
   {
      return true;
   }
   return false;
 }
 
 
// format daty: yyyy-mm-dd
function checkDate(str, flag)
{
   daysInNormYear = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
   daysInLeapYear = new Array(31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
   if (flag==1 || str!="")
   {
      var dateStr=/^([0-9]){4}-([0-9]){2}-([0-9]){2}$/;
          if(dateStr.test(str)==true)
          {
             year = str.substring(0,4);
               month = str.substring(5,7);
               day=str.substring(8,10);
               isLeapYear = !(year%4);

               if (month<=12 && month>0)
               {
                  if(isLeapYear)
                        return (day>0 && day<=daysInLeapYear[(month-1)]);
                      else
                         return (day>0 && day<=daysInNormYear[(month-1)]);
         }         
               else 
                  return false;                 
          }
          else
             return false;
   }
   else
      return true;
}

function checkNIP(str, flag)
{
   if (flag==1 || str!="")
   {
      weights = new Array(6, 5, 7, 2, 3, 4, 5, 6, 7);
      cLength  = 10;
      cModulo  = 11;    
      // zamieniam string na cyferki same
      var num = /-/;
      while(num.test(str))
      {
         str = str.replace(num, "");
      }   
      // sprawdzam czy tylko cyfry
      var bla = /\D/;
      isDigit = true;
      while(bla.test(str))
      {
         str = str.replace(bla, "");
         //errorMessage +="Nieporwny numer NIP\n";
         return false;
      } 
      if (str.length == cLength)
      {
         sum = 0;
         for(i=0; i<weights.length; i++)
         {
            sum += (str.substring(i, (i+1)) * weights[i]);
         }
         lSign = (sum % cModulo);
         rSign = str.substring(9,10);
         return (lSign == rSign)
      }
      else
      {
         return false;
      }  
    }  
    else
    {
         return true;
    }
}

 
function checkREGON(str, flag)
{
   if (flag==1 || str!="")
   {
      weights = new Array(8, 9, 2, 3, 4, 5, 6, 7);
        cLength  = 9;
        cModulo  = 11;    

        // zamieniam string na cyferki same
        var num = /-/;
        while(num.test(str))
        {
           str = str.replace(num, "");
        }   
        // sprawdzam czy tylko cyfry
        var bla = /\D/;
        isDigit = true;
        while(bla.test(str))
        {
           str = str.replace(bla, "");
           //errorMessage +="Nieporwny numer NIP\n";
           return false;
        } 
        if (str.length == cLength)
        {
           sum = 0;
           for(i=0; i<weights.length; i++)
           {
              sum += (str.substring(i, (i+1)) * weights[i]);
           }
           lSign = (sum % cModulo);
           rSign = str.substring(8,9);
           return (lSign == rSign)
        }
        else
        {
           return false;
        }  
   }  
     else
     {
        return true;
     }
}


// sprawdza liczby zmienno przecinkowe i zwykle tez :)
function checkFloat(str, flag)
{
   if (flag==1 || str!="")
   {
      var floatStr=/^([0-9])+([\.]){0,1}([0-9])*$/;
          return (floatStr.test(str));
   }
   else
   {
      return true;
   } 
}

function checkPass(Pass, rePass, flag)
{
   if (flag==1 || str!="")
   {
          if(Pass=="" || Pass!=rePass) errorArray["PasswordRepeat"]=true;
          if(Pass.length < Params.passwordLenght) errorArray["PasswordLenght"]=true;
      return (Pass!="" && (Pass==rePass) && Pass.length >= Params.passwordLenght);
   }
   else
      return true;
}  
   
function markField(field)
{
   field.style.background=Params.errorBG;
}
  
function markPassField(fieldNo)
{
   alert("aaa");
}
  
function unmarkField(field)
{
   field.style.background=Params.clearBG;
}

// dziekuje