<!-- Javascripts für die Prüfung der standartisierten Eingabeformulare -->

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Prüfe alle übergebenen Felder eines Eingabeformulars daraufhin, ob sie leer sind
      Eingabe: die Liste der Elemente des Eingabeformulars und die Liste der zu überprüfenden Felder
      Ausgabe: den Erfolgswert bez. der Prüfung (gültig = true / ungültig = false)
    Bemerkung: keine
   ---------------------------------------------------------------------------------------------------- */
    function checkIsEmpty(elementlist, elements) {
      // Initialisiere den Rückgabewert
      var result;
      result = true;
      // Prüfe alle übergebenen Felder
      for (var key1 in elements) {
        var element = document.getElementById(elements[key1]["id"]);
        if (element.value == "") {
          markField(elementlist, elements[key1]["name"], "error");
          if (result == true) {
            setFocusOnField(elementlist, elements[key1]["name"]);
           }
          result = false;
         }
       }
      // Melde ggf. den Fehler
      if (result == false) {
        alert("Sie müssen alle mit einem Stern markierten Felder ausfüllen.");
       }
      // Rückgabe des Erfolgswertes
      return result;
     }

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Prüfe alle übergebenen Felder eines Eingabeformulars daraufhin, ob sie eine
               E-Mailadresse enthalten
      Eingabe: die Liste der Elemente des Eingabeformulars und die Liste der zu überprüfenden Felder
      Ausgabe: den Erfolgswert bez. der Prüfung (gültig = true / ungültig = false)
    Bemerkung: keine
   ---------------------------------------------------------------------------------------------------- */
    function checkIsEmail(elementlist, elements) {
      // Initialisiere den Rückgabewert
      var result;
      result = true;
      // Prüfe alle übergebenen Felder
      for (var key1 in elements) {
        var element = document.getElementById(elements[key1]["id"]);
        // Initialisiere den Rückgabewert
        result = false;
        // Umgehe den Fall, daß der Wert leer ist
        if (element.value == "") {
          result = true;
         } else {
          // Überprüfe ob die E-Mailadresse genau ein @ Zeichen hat, sowie ob davor und danach Zeichen stehen
          mailarray = element.value.split("@");
          if (mailarray.length == 2) {
            // Überprüfe den spezifischen und Domain-Anteil der E-Mailadresse auf gültige Zeichen.
            if (checkValidCharsInString(mailarray[0], 0)) {
              arrTemp = mailarray[1].split(".");
              // Überprüfe ob sich der Domainenname maximal in TopLevel-, SecondLevel- bzw. Localdomain splittet
              if ((arrTemp.length > 1) && (arrTemp.length <= 4)) {
                // Überprüfen ob die TopLevel-Domain mindestens eine Stelle hat und nur gültige Zeichen enthält
                if (arrTemp[arrTemp.length-1].length > 1) {
                  if (checkValidCharsInString(arrTemp[arrTemp.length-1], 1)) {
                    for (i = 0; i < (arrTemp.length - 1); i++) {
                      // Überprüfe jeden Teil des Domainnamens (mit Ausnahme der TopLevel-Domain) auf mindestens 3 gültige Zeichen
                      result = checkValidCharsInString(arrTemp[i], 2);
                      if (!result){
                        break;
                       }
                     }
                   }
                 }
               }
             }
           }
         }
        // Melde ggf. den Fehler
        if (result == false) {
          markField(elementlist, elements[key1]["name"], "error");
          setFocusOnField(elementlist, elements[key1]["name"]);
          alert("Die von Ihnen eingebene E-Mailadresse ist ungültig.");
          break;
         }
       }
      // Rückgabe des Erfolgswertes
      return result;
     }

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Überprüft, ob bestimmte Zeichen in einem String vorkommen oder nicht.
      Eingabe: der zu prüfende String und ein Optionswert zur Bestimmung der zu durchsuchenden Zeichen
      Ausgabe: den Erfolgswert bez. der Prüfung (gültig = true / ungültig = false)
    Bemerkung: (Hilfsroutine für "checkIsEmail")
   ---------------------------------------------------------------------------------------------------- */
    function checkValidCharsInString(strval, option) {
      // Initialisiere den Rückgabewert
      result = false;
      // Prüfe ob der String nicht leer ist
      if (strval != "") {
        // Definition der erlaubten Sonderzeichen
        pattern = "!#$%&'*+-/=?^_`{|}~.@ß";
        result = true;
        // Durchsuche den übergebenen String nach unerlaubten Zeichen ...
        for (i = 0; i < strval.length; i++) {
          currentChar = strval.charAt(i);
          switch (option) {
            // Durchsuche nach Buchstaben, Zahlen und den erlaubten Sonderzeichen ...
            case 0 :
              // Wenn ein Zeichen nicht erlaubt ist, dann breche die Schleife ab
              if ((pattern.indexOf(currentChar) == -1) && (currentChar.match(/\w/) == null)) {
                result = false;
                break;
               }
              break;
            // Durchsuche nach Buchstaben, Zahlen, sowie den Zeichen ".", "-" und "_" ...
            case 1 :
              // Wenn ein Zeichen nicht erlaubt ist, dann breche die Schleife ab
              if (currentChar.match(/\w/) == null) {
                result = false;
                break;
               }
              break;
            // Durchsuche nach Buchstaben, Zahlen sowie dem Zeichen "_" ...
            case 2 :
              // Wenn ein Zeichen nicht erlaubt ist, dann breche die Schleife ab
              if ((currentChar.match(/\w/) == null) && (currentChar.match(/\./) == null) && (currentChar.match(/\-/) == null)) {
                result = false;
                break;
               }
              break;
            default:
              result = false;
              break;
           }
         }
       }
      // Rückgabe des ermittelten Wertes
      return result;
     }

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Prüfe alle übergebenen Felder eines Eingabeformulars daraufhin, ob sie ein
               Datum enthalten
      Eingabe: die Liste der Elemente des Eingabeformulars und die Liste der zu überprüfenden Felder
      Ausgabe: den Erfolgswert bez. der Prüfung (gültig = true / ungültig = false)
    Bemerkung: keine
   ---------------------------------------------------------------------------------------------------- */
    function checkIsDate(elementlist, elements) {
      // Initialisiere den Rückgabewert
      var result;
      result = true;
      // Prüfe alle übergebenen Felder
      for (var key1 in elements) {
        var element = document.getElementById(elements[key1]["id"]);
        // Initialisiere den Rückgabewert
        result = false;
        // Umgehe den Fall, daß der Wert leer ist
        if (element.value == "") {
          result = true;
         } else {
          // Formatiere ggf. ein Datum nach DIN 5008 ins übliche Format um
          tempdate = element.value.split("-");
          if (tempdate.length == 3) {
            element.value = tempdate[2] + "." + tempdate[1] + "." + tempdate[0];
           }
          // Überprüfe, ob das Array genau drei Elemente hat
          arrDate = element.value.split(".");
          if (arrDate.length == 3) {
            // Überprüfe, ob das erste Element ein Tag (1 bis 31) ist
            if (arrDate[0].substr(0, 1) == "0") {
              arrDate[0] = arrDate[0].substr(1, arrDate[0].length - 1);
             }
            if ((arrDate[0].length < 3) && (parseInt(arrDate[0]) >= 1) && (parseInt(arrDate[0]) <= 31)) {
              if (arrDate[0].length == 1) {
                arrDate[0] = "0" + arrDate[0];
               }
              // Überprüfe, ob das zweite Element ein Monat (1 bis 12) ist
              if (arrDate[1].substr(0, 1) == "0") {
                arrDate[1] = arrDate[1].substr(1, arrDate[1].length - 1);
               }
              if ((arrDate[1].length < 3) && (parseInt(arrDate[1]) >= 1) && (parseInt(arrDate[1]) <= 12)) {
                if (arrDate[1].length == 1) {
                  arrDate[1] = "0" + arrDate[1];
                 }
                // Überprüfe, ob das dritte Element eine Zahl ist und eine Länge zwischen 1 und 4 besitzt
                if (!(isNaN(arrDate[2])) && (arrDate[2].length <= 4)) {
                  if (arrDate[2].length == 1) {
                    arrDate[2] = "0" + arrDate[2];
                   }
                  if (arrDate[2].length == 2) {
                    if (parseInt(arrDate[2]) <= 25) {
                      arrDate[2] = "20" + arrDate[2];
                     } else {
                      arrDate[2] = "19" + arrDate[2];
                     }
                   }
                  // Festlegen des Wertes der zurückgegeben wird
                  element.value = arrDate[0] + "." + arrDate[1] + "." + arrDate[2];
                  result = true;
                 }
               }
             }
           }
         }
        // Melde ggf. den Fehler
        if (result == false) {
          markField(elementlist, elements[key1]["name"], "error");
          setFocusOnField(elementlist, elements[key1]["name"]);
          alert("Das von Ihnen angegebene Datum ist ungültig.");
          break;
         }
       }
      // Rückgabe des Erfolgswertes
      return result;
     }

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Prüfe alle übergebenen Felder eines Eingabeformulars daraufhin, ob sie ein
               Geburtsdatum enthalten
      Eingabe: die Liste der Elemente des Eingabeformulars und die Liste der zu überprüfenden Felder
      Ausgabe: den Erfolgswert bez. der Prüfung (gültig = true / ungültig = false)
    Bemerkung: keine
   ---------------------------------------------------------------------------------------------------- */
    function checkIsBirthday(elementlist, elements) {
      // Initialisiere den Rückgabewert
      var result;
      // Aufruf der Schwesterfunktion
      result = checkIsDate(elementlist, elements);
      if (result == true) {
        // Prüfe alle übergebenen Felder
        for (var key1 in elements) {
          var element = document.getElementById(elements[key1]["id"]);
          // Initialisiere den Rückgabewert
          result = false;
          // Umgehe den Fall, daß der Wert leer ist
          if (element.value == "") {
            result = true;
           } else {
            // Initialisiere die zuvergleichenden Datumswerte
            today = new Date();
            birthday = new Date();
            // Bereite das zuprüfende Datum vor
alert(element.value);
            arrTemp = element.value.split(".");
            birthday.setDate(arrTemp[0]);
            birthday.setMonth(arrTemp[1] - 1);
            birthday.setYear(arrTemp[2]);
            // Konvertiere die zuvergleichenden Datumswerte in Zeitstempel
            today = today.getTime();
            birthday = birthday.getTime();
            // Vergleiche, ob das Datum kleiner dem aktuellen Datum
            if (birthday < today) {
              result = true;
             }
           }
          // Melde ggf. den Fehler
          if (result == false) {
            markField(elementlist, elements[key1]["name"], "error");
            setFocusOnField(elementlist, elements[key1]["name"]);
            alert("Laut dem von Ihnen angegebenen Geburtstag würde der gesuchte Mensch erst noch geboren werden.");
            break;
           }
         }
       }
      // Rückgabe des Erfolgswertes
      return result;
     }

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Prüfe alle übergebenen Felder eines Eingabeformulars daraufhin, ob sie ein
               Geburtsdatum enthalten
      Eingabe: die Liste der Elemente des Eingabeformulars und die Liste der zu überprüfenden Felder
      Ausgabe: den Erfolgswert bez. der Prüfung (gültig = true / ungültig = false)
    Bemerkung: keine
   ---------------------------------------------------------------------------------------------------- */
    function checkIsBirthdayBWI(elementlist, elements) {
      // Initialisiere den Rückgabewert
      var result;
      // Aufruf der Schwesterfunktion
      result = checkIsDate(elementlist, elements);
      if (result == true) {
        // Prüfe alle übergebenen Felder
        for (var key1 in elements) {
          var element = document.getElementById(elements[key1]["id"]);
          // Initialisiere den Rückgabewert
          result = false;
          // Umgehe den Fall, daß der Wert leer ist
          if (element.value == "") {
            result = true;
           } else {
            // Initialisiere die zuvergleichenden Datumswerte
            today = new Date();
            birthday = new Date();
            // Bereite das zuprüfende Datum vor
            arrTemp = element.value.split(".");
            birthday.setDate(arrTemp[0]);
            birthday.setMonth(arrTemp[1] - 1);
            birthday.setYear(arrTemp[2]);
            // Errechne die Differenz zwischen dem Geburtstag und dem heutigen Tag in Tagen
            daystoday = (((today.getFullYear() * 12) + (today.getMonth() + 1)) * 31) + today.getDate();
            daysbirthday = (((birthday.getFullYear() * 12) + (birthday.getMonth() + 1)) * 31) + birthday.getDate();
            deltaDays = daystoday - daysbirthday;
            // Errechne die kleinste und die höchste zugelassene Differenz
            deltaDaysMin = 16 * 12 * 31;
            deltaDaysMax = 100 * 12 * 31;
            // Vergleiche, ob die bestimmte Differenz im gültigen Bereich liegt
            if ((deltaDays <= deltaDaysMax) && (deltaDays >= deltaDaysMin)) {
              result = true;
             }
           }
          // Melde ggf. den Fehler
          if (result == false) {
            markField(elementlist, elements[key1]["name"], "error");
            setFocusOnField(elementlist, elements[key1]["name"]);
            alert("Laut dem von Ihnen angegebenen Geburtstag ist der gesuchte Mensch jünger als 16 oder älter als 100 Jahre. \r\nDies ist nicht zulässig!");
            break;
           }
         }
       }
      // Rückgabe des Erfolgswertes
      return result;
     }

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Prüfe alle übergebenen Felder eines Eingabeformulars daraufhin, ob sie eine
               Telefonnummer enthalten
      Eingabe: die Liste der Elemente des Eingabeformulars und die Liste der zu überprüfenden Felder
      Ausgabe: den Erfolgswert bez. der Prüfung (gültig = true / ungültig = false)
    Bemerkung: keine
   ---------------------------------------------------------------------------------------------------- */
    function checkIsTelephoneNumber(elementlist, elements) {
      // Initialisiere den Rückgabewert
      var result;
      result = true;
      // Prüfe alle übergebenen Felder
      for (var key1 in elements) {
        var element = document.getElementById(elements[key1]["id"]);
        // Initialisiere den Rückgabewert
        result = true;
        // Umgehe den Fall, daß der Wert leer ist
        if (element.value == "") {
          result = true;
         } else {
          // Prüfe das Element
          if (element.value.length != 0) {
            for (i = 0; i < element.value.length; i++) {
              currentChar = element.value.charAt(i);
              // Wenn in der Telefonnnr andere Zeichen enthalten sind dann
              if ("0123456789".indexOf(currentChar) == -1) {
                // Überprüfe ob es eines von diesen 3 Zeichen ist. Wenn nein dann breche die Schleife ab und gebe false zurück
                if ("/- ".indexOf(currentChar) == -1) {
                  result = false;
                  break;
                 }
               }
             }
           } else {
            result = false;
           }
         }
        // Melde ggf. den Fehler
        if (result == false) {
          markField(elementlist, elements[key1]["name"], "error");
          setFocusOnField(elementlist, elements[key1]["name"]);
          alert("Die von Ihnen angebene Telefonnummer enthält ungültige Zeichen.\r\nTelefonnummern dürfen nur aus Ziffer sowie den Zeichen / und - bestehen.");
          break;
         }
       }
      // Rückgabe des Erfolgswertes
      return result;
     }

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Markiere ein Feld eines Eingabeformulars als fehlerhaft bzw. normal
      Eingabe: die Liste der Elemente des Eingabeformulars, den Namen des betroffenen Feldes, sowie
               ein Indikator für dessen zukünftigen Status (fehlerhaft = error / normal = normal)
      Ausgabe: nichts
    Bemerkung: keine
   ---------------------------------------------------------------------------------------------------- */
    function markField(elementlist, elementname, state) {
      // Vereinheitliche den übergebenen Status
      if (state.toLowerCase() == "error") {
        state = "error";
       } else {
        state = "normal";
       }
      // Suche das betroffene Element in der entsprechenden Liste
      for (var key1 in elementlist) {
        var elementFounded = false;
        for (var key2 in elementlist[key1]) {
          if (key2 == "fields") {
            for (var key3 in elementlist[key1][key2]) {
              if (key3 == elementname) {
                elementFounded = true;
               }
             }
           }
         }
//alert(elementname);
        // Manipuliere die zugewiesenen CSS-Klassen entsprechend dem gewählten Status
        if (elementFounded == true) {
          for (var key2 in elementlist[key1]) {
            if (key2 == "element") {
              var element;
              element = elementlist[key1][key2];
              var tag = document.getElementById(element["id"]);
              tag.className = element["CSSclass:" + state];
//alert(element["CSSclass:" + state]);
             }
            if (key2 == "label") {
              var label;
              label = elementlist[key1][key2];
              var tag = document.getElementById(label["id"]);
              tag.className = label["CSSclass:" + state];
             }
            if (key2 == "fields") {
              for (var key3 in elementlist[key1][key2]) {
                var field;
                field = elementlist[key1][key2][key3];
                var tag = document.getElementById(field["id"]);
                tag.className = field["CSSclass:" + state];
               }
             }
           }
         }
       }
     }

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Setzt den Focus auf ein Feld eines Eingabeformulars
      Eingabe: die Liste der Elemente des Eingabeformulars, den Namen des betroffenen Feldes
      Ausgabe: nichts
    Bemerkung: keine
   ---------------------------------------------------------------------------------------------------- */
    function setFocusOnField(elementlist, elementname) {
      // Suche das betroffene Element in der entsprechenden Liste
      for (var key1 in elementlist) {
        var elementFounded = false;
        for (var key2 in elementlist[key1]) {
          if (key2 == "fields") {
            for (var key3 in elementlist[key1][key2]) {
              if (key3 == elementname) {
                elementFounded = true;
               }
             }
           }
         }
        // Setze den Focus auf das betroffene Element
        if (elementFounded == true) {
          for (var key2 in elementlist[key1]) {
            if (key2 == "fields") {
              for (var key3 in elementlist[key1][key2]) {
                var field;
                field = elementlist[key1][key2][key3];
                var tag = document.getElementById(field["id"]);
                tag.focus();
                break;
               }
             }
           }
         }
       }
     }

/* ----------------------------------------------------------------------------------------------------
      Aufgabe: Markiert alle Felder eines Eingabeformulars als fehlerhaft bzw. normal
      Eingabe: die Liste der Elemente des Eingabeformulars und ein Indikator für den zukünftigen
               Status (fehlerhaft = error / normal = normal)
      Ausgabe: nichts
    Bemerkung: keine
   ---------------------------------------------------------------------------------------------------- */
    function markAllFields(elementlist, state) {
      // Suche das betroffene Element in der entsprechenden Liste
      for (var key1 in elementlist) {
        var elementFounded = false;
        for (var key2 in elementlist[key1]) {
          if (key2 == "fields") {
            for (var key3 in elementlist[key1][key2]) {
              markField(elementlist, key3, state);
             }
           }
         }
       }
     }