/*
	* validierung.js
	 
 	* Ersetzt die Funktion checkform(), erweitert diese um Prüfung von Nicht-Pflichtfeldern und Prüfung eines Eingabewiederholung
 	
	* Wird beim Absenden eines Formulars aufgerufen und gibt entweder true oder false zurück
	* bei false kann das Absenden des Formulars damit unterbunden werden (Anweisung: onsubmit="return pruefe_eingaben(this,'<%pfad_err_bilddatei%>');").
	* 
	* Prüft, ob Pflichfelder ausgefüllt wurden und generiert dynamisch Fehlersymbole, eine Fehlerbox und Farbmarkierung der betroffenen Felder
	* Prüft zusätzlich, ob Feldinhalte der Validierungvorschfift entsprechen und generiert ebenfalls Fehlersymbole und Farbmarkierung der betroffenen Felder
	* 
	* Im Formular kann genau ein Input-Feld hinterlegt werden, welches kommagetrennt  2 zu vergleichende Feld-IDs und eine Fehlermeldung enthält:
	* Beispiel: <input type="hidden" id="compfields" name="compfields" value="email,wdh_email,Email-Felder sind nicht gleich!">
	* Ist ein solches Feld enthalten, werden die Inhalte dieser beien Felder auf Gleichheit geprüft
	* 
	* Die Optionen 'Pflichtfeld' und 'Validierungsart' werden im Formularbaukasten von RedDot bei den einzelnen Elementen eingebaut (Optionsliste)
	* Beim Aufruf der Seite werden über die 2 JavaScripte <Add_Field> und <Add_Val_Field> 2 ARRAYS dynamisch gefüllt
	* Die ARRAYS <FieldArray> und <ValFieldsArray> enthalten dann alle Angaben, die zur Laufzeit für die Fehlerprüfung erforderlich sind
	* Das ARRAY <EditFieldsArray> enthält die Liste von feld-IDs, die im Formular bearbeitet werden dürfen 
	* @author Karsten Bode
 	* @version 1 20081014
 	* 
 	* Änderungen
 	*/

    /* Globale Parameter für die Fehlerausgabe (Formatierung HG-Farbe bei Fehler und Fehlersymbol)*/
	/* -------------------------- */
    /* vordefinierte Variablen    */
    /* -------------------------- */
 
    var checkform_fehler = "#fcc";
    var checkform_ok     = "transparent";
    var fehler_img       = "";
    var buttontyp        = "image";   // Typ des Sendebuttons. Vor diesem Button wird die Fehlerbox plaziert. 
 
    /* werden bei jedem Seitenaufruf neu initialisiert  */
   
    /* array mit input-Feldern, die ausgefüllt werden müssen (=Pflichtfelder) */
    var FieldArray = new Array();
    
    /* array mit input-Feldern für die Validierung */
    var ValFieldsArray = new Array();
    
    /* array mit den Validierungsvorschriften (=string z.B. PLZ) */
    var ValRulesArray = new Array();
    
    /* array mit input-Feldern, die bearbeitet werden dürfen */
	var EditFieldsArray = new Array();
	
    var comp_error = "";
    var compfeld1_id = "";
    var compfeld2_id = "";
    var compfeld1_inhalt = "";
    var compfeld2_inhalt = "";
    
    /* prüft das Formular wie oben beschrieben
     * 
     * @param of Objekt des Formulars
     * @param err_img_pfad Fehler-Image als Pfad-Angabe zur Datei
     * @param sendebuttontyp Typ des Buttons (submit, image oder button)
     * @return bool true = Formular darf abgeschickt werden
     */
    function pruefe_eingaben(of,err_img_pfad,sendebuttontyp) {
     
       /* werden bei jedem Versuch, das Formular abzusenden, neu initialisiert  */
     	
    	var reqfields = Array();
        var valfields = new Array();
        var valrules = new Array();
        var err_fields = new Array();
        
        var em,i,n,f,ty;
       
       /* Übergebenen Pfad für die Image-Datei des Fehlersymbols speichern */
        fehler_img = err_img_pfad;
       /* Buttontyp speichern */
       if(sendebuttontyp)  buttontyp = sendebuttontyp;
       /* neu initialisieren der Arrays <valfields> */
        valfields = ValFieldsArray;
        valrules = ValRulesArray;
        
            
       /* neu initialisieren des Arrays <compare_fields> */
        if(document.getElementById('compfields')) {
            var s =document.getElementById('compfields').value;
            var cf = s.split(',');
            if(cf[0]!="") {
                if(document.getElementById(cf[0])) {
                    compfeld1_id = cf[0];
                    compfeld1_inhalt = document.getElementById(compfeld1_id).value;
                }
            }
            if(cf[1]!="") {
                if(document.getElementById(cf[1])) {
                    compfeld2_id = cf[1];
                    compfeld2_inhalt = document.getElementById(compfeld2_id).value;
                }
            }
            comp_error = cf[2];
        }
     
        /* -------------------------------------------------------------------------------------------- */  
        /* Array mit den IDs der vordefinierten Formularblöcke - Inhalte werden in reqfields übertragen */
        /* -------------------------------------------------------------------------------------------- */
        var requiredFieldsArray = Array('required_firma','required_ansprech');
        if(document.getElementById('errormsg')){
           em=document.getElementById('errormsg');
           em.parentNode.removeChild(em);
        }
        for (i=0; i < requiredFieldsArray.length; i++) {
             if(document.getElementById(requiredFieldsArray[i])) {    /* existiert der Block? */
                reqfields = reqfields.concat(document.getElementById(requiredFieldsArray[i]).value.split(',')); /* aufsplitten nach Komma */
            }
        }
        
        /* ------------------------------------------------ */
        /* zusätzliche Felder aus ARRAY FieldArray anfügen  */
        /* ------------------------------------------------ */
        if (FieldArray.length > 0) reqfields = reqfields.concat(FieldArray);
        
        /* --------------------------------------------------------------- */
        /* Fehlersymbole und Markierungen aller Pflichtfelder zurücksetzen */
        /* --------------------------------------------------------------- */
       
        
        
        for (i=0; i < reqfields.length; i++) { 
        	
      	
        	f = document.getElementById(reqfields[i]);
        	fehlerimg_id = "fehlerimg_" + reqfields[i];
            if(document.getElementById(fehlerimg_id)) {
                document.getElementById(fehlerimg_id).style.visibility="hidden";            
            }
            ty=f.type.toLowerCase();
            if(ty=="text" || ty=="textarea") f.style.background = checkform_ok;
        
        }    


        
        
        /* --------------------------------------------------------------------- */
        /* Fehlersymbole und Markierungen aller Validierungsfelder zurücksetzen  */
        /* --------------------------------------------------------------------- */
           for (i=0; i < valfields.length; i++) { 
      
        	   f = document.getElementById(valfields[i]);
               fehlerimg_id = "fehlerimg_" + valfields[i];
               if(document.getElementById(fehlerimg_id)) {
                   document.getElementById(fehlerimg_id).style.visibility="hidden";            
               }
               ty=f.type.toLowerCase();
               if(ty=="text" || ty=="textarea") f.style.background = checkform_ok;
              }
       

 // alert("reqfilelds[0]: " + reqfields[0]);
 // alert("valfields[0]: " + valfields[0]);
 // alert("valrules[0]: " + valrules[0]);



        /* ------------------------------------------------------------------------- */
        /* Fehlersymbole für Pflichtfelder neu generieren. bei Pflichtfeldverletzung */
        /* Validierungsoption zurücksetzen, da Fehlersymbole sonst 2 x erz. werden   */
        /* ------------------------------------------------------------------------- */
        for (i=0; i < reqfields.length; i++) { 
               
        	    
        	//alert("FN pruefe_eingaben (validierung.js) " + reqfields[i]);
        	 
        	    
                f = document.getElementById(reqfields[i]);
                if(f) {
                    
                	ty=f.type.toLowerCase();
                    switch(ty) {    /* Typauswahl */
                        case 'text':        if (f.value=='') {
                                                gebe_fehler_aus(f.id,of);
                                                err_fields[f.id] = '1';
                                            }       
                                            break;
                        case 'textarea':    if (f.value=='') {
                                                gebe_fehler_aus(f.id,of);
                                                err_fields[f.id] = '1';
                                              }       
                                            break;
                        case 'checkbox':    if (!f.checked) {
                                                gebe_fehler_aus(f.id,of);
                                                err_fields[f.id] = '1';
                                            }       
                                            break;
                        
                        case "select-one":  break; // Combo-Box
                        
                        case 'hidden':      /* verstecktes Pflichtfeld: nur zur Anzeige des Fehlersymbols für gleichnamige Radiogruppe */
                        	  				if (f.value=='') {
                        	  					gebe_fehler_aus(f.id,of);
                        	  					err_fields[f.id] = '1';
                        	  				}
                        	
                        	                /* 
                        	                var opt_ok = false;
                    		                var optgroup = document.getElementsByName(f.id);
                                            for(var grp=0;grp<optgroup.length;grp++) {
                                    			if(document.getElementsByName(f.id)[grp].checked) opt_ok=true;
                                            }    
                                            
                                             if(opt_ok==false) {
                    		                    gebe_fehler_aus(f.id,of);
                                                err_fields[f.id] = '1';
                    		                }
                    		                */	
                    		                break;                     
                                            
                    }
                }
        }
        
        /* --------------------------------------------------------------------------------- */
        /* Fehlersymbole für Nicht-Pflichtfelder, die aber validiert werden sollen, erzeugen */
        /* --------------------------------------------------------------------------------- */

        for (i=0; i < valfields.length; i++) { 
            
        	//alert(valfields[i]);
        	
            f = document.getElementById(valfields[i]);
            if(f) {
                if(!err_fields[f.id]=='1') {
                    if(validiere_feld(f.value,valrules[i]) == false) {
                        gebe_fehler_aus(f.id,of);
                        err_fields[f.id]='1';
                    }
                }
            }
        }
    
       /* ---------------------------------------------------------------- */ 
       /* Überprüfen der compare-Felder (falls Option aktiviert ist).      */
       /* ---------------------------------------------------------------- */

        if((compfeld1_id != "") && (compfeld2_id != "")) {
            
            if(compfeld1_inhalt != compfeld2_inhalt) { 
                if(!err_fields[compfeld1_id]=='1') gebe_fehler_aus(compfeld1_id,of);
                if(!err_fields[compfeld2_id]=='1') gebe_fehler_aus(compfeld2_id,of);
                erweitere_fehlerbox(comp_error,of);
                return(false);
            }
        }
            
       if(document.getElementById('errormsg')) {
          return false;
        } else {
           return true;
        }
    
    }
  
   
  
    /*
     * wertet die Validierungsvorschrift aus
     * 
     * @param feldinhalt Inhalt des Feldes
     * @param string validierungstyp (z.B. plz, entsprechend der Optionsliste im CMS)
     * @return bool true, wenn Inhalt valide
     */
    function validiere_feld(feldinhalt,validierungstyp) {
        
        /* Die hier angegebenen Werte, müssen denen entsprechen, die in der Optionsliste für die Validierung im RedDot auswählbar sind */
        
        var i,set,zeichen;
        var laenge = feldinhalt.length;    
        if(laenge==0) return(true); // leere Felder lösen bereits als Pflichtfelder einen Fehler aus, ansonsten dürfen sie leer sein
        
        switch(validierungstyp) {
            case "rufnummer":     set = "+1234567890/()- ";  
                                break;
            case "email":         if(!is_email_addr(feldinhalt)) return(false);
                                return(true);
                                break;
            case "plz":            set = "1234567890";  
                                if (laenge!=5) return(false);
                                break;
            case "konto":        set = "1234567890";  
                                break;
            case "blz":            set = "1234567890";
                                if (laenge!=8) return(false);  
                                break;
            case "ziffern":        set = "1234567890";  
                                break;
        }
        for (i=0;i<=laenge;i++) {
            zeichen=feldinhalt.charAt(i);
            if (set.indexOf(zeichen)==-1) return(false);
        }
        return(true); /* alle Prüfungen bestanden */
    }
    
    
    
    /*
     * gibt ein Fehler-Bild hinter der Feld-Id aus,
     * und erzeugt die Fehlerbox, falls sie unten (unter dem submit) noch nicht vorhanden ist
     * 
     * @param id Feld-Id des Eingabefeldes
     * @param of DOM-Objekt des Formulars
     */
    function gebe_fehler_aus(id,of) {
       
       
    	//alert("validierung.js gebe_fehler_aus: " + id);
    	
    	
    	/* generiert Fehlersymbol und Markierung für Feld mit <id> und generiert Fehlerbox, falls noch nicht vorhanden */
        var se,i,nli,na;
        var fehlerimg_id = 'fehlerimg_' + id;
        
        se=document.getElementById(id);

        /* nur, wenn das Fehler-Image nicht existiert, wird es neu erzeugt und ausgegeben */
        if(!document.getElementById(fehlerimg_id)) {
            i=document.createElement('img');
            i.src=fehler_img;
            i.alt='Error';
            i.title='Validierungsfehler im Feld - bitte korrigieren!';
            i.id= fehlerimg_id;        
            se.parentNode.insertBefore(i,se.firstChild);
        } else {
            document.getElementById(fehlerimg_id).style.visibility="visible";
        }
        se.style.background = checkform_fehler;
        generiere_standard_fehlerbox(of);
       
    }
    
    /*
     * erzeugt die Fehlerbox
     * 
     * @param f DOM-Objekt des Formulars
     */
    function generiere_standard_fehlerbox(f) {
       
        /* sucht im Formular mit der id <f> nach einem input-Element vom Typ <buttontyp> und alternativ nach dem div-Abschnitt <fboxpos>
           wenn <fboxpos> existiert, wird an dieser Stelle die Fehlerbox ausgegeben, ansonsten vor dem ersten Button vom Typ <buttontyp>
           die Fehlerbox wird nur dann erzeugt, wenn sie noch nicht existiert
        */
        
    	var gefunden = false;
        
        if(!document.getElementById('errormsg')) {
        
            /* Box mit Inhalten definieren */
        	var em=document.createElement('p');
            em.id='errormsg';
            em.style.border='1px solid #c00';
            em.style.padding='5px';
            em.style.width='20em';
            em.style.marginLeft='80px'; //110px
            em.style.marginTop='10px';
            em.style.marginBottom='10px';
            em.appendChild(document.createTextNode('Ihre Angaben in den Eingabefeldern mit einem '));
            i=document.createElement('img');
            i.src=fehler_img;
            i.alt='Error';
            i.title='Validierungsfehler im Feld - bitte korrigieren!';
            em.appendChild(i);
            em.appendChild(document.createTextNode(' fehlen oder entsprechen nicht den Regeln!'));
            
            /* Box vor Element <fboxpos> plazieren, falls dieses existiert */
            if(document.getElementById("fboxpos")) {
            	
            	einfuegepunkt = document.getElementById("fboxpos");
            	einfuegepunkt.parentNode.insertBefore(em,einfuegepunkt);
            	return;
            }
            
            /* Ansonsten nach Element vom Typ <buttontyp> suchen, vor dem die Box eingefügt werden soll */
            for(var i = 0; i < f.getElementsByTagName('input').length;i++) {
                nowelm = f.getElementsByTagName('input')[i];
                switch(buttontyp) {
                    case "button":     if(/button/i.test(nowelm.getAttribute('type'))) { 
                                        var sb = nowelm;
                                        gefunden = true;
                                    }
                                    break;
                    case "submit":     if(/submit/i.test(nowelm.getAttribute('type'))) { 
                                        var sb = nowelm;
                                        gefunden = true;
                                    }
                                    break;
                    case "image":     if(/image/i.test(nowelm.getAttribute('type'))) { 
                                        var sb = nowelm;
                                        gefunden = true;
                                    }
                                    break;
                
                }
                if(gefunden == true) break;
            }    
            
            if(gefunden==true) {	
            	sb.parentNode.insertBefore(em,sb);
            }
         }
    
    }
    
    /*
     * erweitert die Fehlerbox um den Text newtext
     * 
     * @param string newtext Text der neuen Fehlermeldung
     * @param of DOM-Objekt des Formulars
     */
    function erweitere_fehlerbox(newtext,of) {
    
        /* fügt eine neue Textzeile an den Text in der Fehlerbox an */
        /* wenn die Fehlerbox noch nicht existiert, wird sie zuerst erzeugt */
        
        var ausgabetext = "\n" + newtext;
        if(!document.getElementById('errormsg')) {
            generiere_standard_fehlerbox(of);
        }
           if(document.getElementById('errormsg')) {
            var em = document.getElementById('errormsg');
            em.appendChild(document.createTextNode(ausgabetext));
        }
    }
 
    /*
     * prüft ob string eine valide E-Mail-Adresse ist
     * 
     * @param string str E-Mail-Adresse
     * @return bool true wenn str valide
     */
    function is_email_addr(str) {
        /* Prüfung auf korrekte Mailadresse */
        return str.match(/^[\w-]+(\.[\w-]+)*@([\w-]+\.)+[a-zA-Z]{2,7}$/);
    }    
    
    /*
     * Fügt ein Validierungsfeld zu dem array ValFieldsArray hinzu
     * und eine Validierungsvorschrift zu dem array ValRulesArray hinzu
     * 
     * @param field_id ist die id des Eingabe-Feldes aus dem Formular
     * @param string valtype Validierungsvorschrift entsprechend Optionsliste aus dem CMS
     */
	function Add_Val_Field(field_id,valtype){
       /* fügt zur Laufzeit ein Feld dem Prüfarray valfields hinzu */
       /* (wird in den jeweiligen Content Klassen für die Formularelemente aufgerufen) */
        ValFieldsArray.push(field_id);
        ValRulesArray.push(valtype);
    }

	/*
	 * fügt die Feld-Id eines bearbeitbaren Formular-Feldes zum array EditFieldsArray hinzu
	 * 
	 * @param field_id
	 */
	function Add_Edit_Field(field_id){
       /* fügt zur Laufzeit ein Feld dem Prüfarray editfields hinzu */
       /* (wird in den jeweiligen Content Klassen für die Formularelemente aufgerufen) */
		
		EditFieldsArray.push(field_id);
    }

	/*
	 * 
	 */
	function Add_Field(field_id){
       /* fügt zur Laufzeit ein Feld dem Prüfarray zu (wird dann an <valfields> angehängt) */
       /* (wird in den jeweiligen Content Klassen für die Formularelemente aufgerufen) */
       	
		
		FieldArray.push(field_id);
    }
	

	
	function radio_auswahl(radio_name) {

		// Ermittelt den ausgewählten Value einer Gruppe mit Radiobuttons
	    // Jede Radio_option muß die 4-stellige Formularfeld_id und den Zusatz '_optgrp' tragen
	    // Diese Funktion wird nach aktualisierung eines der Radio-Felder aufgerufen und  
	    // speichert den aktuellen Auswahlwert in das versteckte Feld mit Formularfeld_id 
	        
	    // wenn kein radio_name übergeben wurde, nichts machen 
	    if(radio_name=="") return;
	    var radio_grpname = radio_name.substr(0,4);
	    // wenn das versteckte Feld <radio_grpname> nicht vorhanden ist, nichts machen   
	    if(!document.getElementById(radio_grpname)) return; 
	    //Anzahl der Radios in der Gruppe   
	    var l = document.getElementsByName(radio_name).length;
	    for(x=0;x<l;x++) {
	        if(document.getElementsByName(radio_name)[x].checked==true) {   
	         	document.getElementById(radio_grpname).value =document.getElementsByName(radio_name)[x].value;
	           	return;
	        }
	    }
	    // nichts ausgewählt oder Radiogruppe nicht vorhanden
	    document.getElementById(radio_grpname).value = "";
	    	
	    }    

	
	
	
	function resetForm() {
		
		/* stellt die Formatierung der Formularfelder wieder auf den Ausgangszustand zurück und entfernt Fehler und Warnsymbole */
        
		/* -------------------------------------------------------------------------------------------- */  
        /* Array mit den IDs der vordefinierten Formularblöcke - Inhalte werden in reqfields übertragen */
        /* -------------------------------------------------------------------------------------------- */
        var requiredFieldsArray = Array('required_firma','required_ansprech');
        var reqfields = Array();
        var valfields = new Array();
        
        if(document.getElementById('errormsg')){
           em=document.getElementById('errormsg');
           em.parentNode.removeChild(em);
        }
        for (i=0; i < requiredFieldsArray.length; i++) {
             if(document.getElementById(requiredFieldsArray[i])) {    /* existiert der Block? */
                reqfields = reqfields.concat(document.getElementById(requiredFieldsArray[i]).value.split(',')); /* aufsplitten nach Komma */
            }
        }
        
        /* ------------------------------------------------ */
        /* zusätzliche Felder aus ARRAY FieldArray anfügen  */
        /* ------------------------------------------------ */
        if (FieldArray.length > 0) reqfields = reqfields.concat(FieldArray);
        
        /* --------------------------------------------------------------- */
        /* Fehlersymbole und Markierungen aller Pflichtfelder zurücksetzen */
        /* --------------------------------------------------------------- */
        for (i=0; i < reqfields.length; i++) { 
            
        	// nix
        	f = document.getElementById(reqfields[i]);
            fehlerimg_id = "fehlerimg_" + reqfields[i];
            if(document.getElementById(fehlerimg_id)) {
                document.getElementById(fehlerimg_id).style.visibility="hidden";            
            }
            ty=f.type.toLowerCase();
            if(ty=="text" || ty=="textarea") f.style.background = checkform_ok;
        }    

        /* --------------------------------------------------------------------- */
        /* Fehlersymbole und Markierungen aller Validierungsfelder zurücksetzen  */
        /* --------------------------------------------------------------------- */
           for (i=0; i < valfields.length; i++) { 
               f = document.getElementById(valfields[i]);
               fehlerimg_id = "fehlerimg_" + valfields[i];
               if(document.getElementById(fehlerimg_id)) {
                   document.getElementById(fehlerimg_id).style.visibility="hidden";            
               }
               ty=f.type.toLowerCase();
               if(ty=="text" || ty=="textarea") f.style.background = checkform_ok;
           }		
		
	}
	
	
	function leere_alle_formularfelder() {
		
		if(!document.getElementById("kb_form")) return;
		for(var i=0; i<document.forms["kb_form"].length; i++) {
			if (document.forms["kb_form"].elements[i].type == "text") {
				document.forms["kb_form"].elements[i].value = "";
			}
			if (document.forms["kb_form"].elements[i].type == "textarea") {
				document.forms["kb_form"].elements[i].value = "";
			}
			if (document.forms["kb_form"].elements[i].type == "checkbox") {
				document.forms["kb_form"].elements[i].checked = false;
			}
		} 
		
	}
	
	
	function test_editfields() {
		
		for (i=0; i < EditFieldsArray.length; i++) { 
            
            alert(EditFieldsArray[i]);
		}	
	}