//<script language="javaScript">


function clsValidate()
{
	this.isPLZ = clsValidate_isPLZ;
	this.isNaN = clsValidate_isNaN;
	this.isCurrency = clsValidate_isCurrency;
	this.isAccountNumber  = clsValidate_isAccountNumber;
	this.isBLZ = clsValidate_isBLZ;
	this.isTelefon = clsValidate_isTelefon;
	this.isAlphaText = clsValidate_isAlphaText;
	this.isDate = clsValidate_isDate;
	this.isTime = clsValidate_isTime;
	this.isWildCard = clsValidate_isWildCard;
	this.isLetter = clsValidate_isLetter;
	this.isLetter2 = clsValidate_isLetter2;
	this.isSurName = clsValidate_isSurName;
	this.isStreet = clsValidate_isStreet;
	this.isZipCode = clsValidate_isZipCode;
	this.isPhoneNumber = clsValidate_isPhoneNumber;
	this.isMailAddress = clsValidate_isMailAddress;
	this.isPLZSearch = clsValidate_isPLZSearch;
	this.isDateSearch = clsValidate_isDateSearch;
	this.isTimeSearch = clsValidate_isTimeSearch;
	this.isDateSearch2 = clsValidate_isDateSearch2;
	this.isErgebnisIDSearch = clsValidate_isErgebnisIDSearch;
	this.isSurNameSearch = clsValidate_isSurNameSearch;
	this.isForbiddenLetter =clsValidate_isForbiddenLetter;
}

function clsValidate_isForbiddenLetter(sValue)
{
/*
	Notes: Stellt sicher das eingegebenes Zeichen keine Schwierigkeiten in SQL oder VB-Code erzeugn können.
		Da sind: ",',--,/*
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] fsp: 28.02.03: 
*/	
	var exp = /[\'\"]/;
	var exp2 = /(\-\-)/;
	var exp3 = /(\/\*)/;
	if (exp.test(sValue) || exp2.test(sValue) || exp3.test(sValue)){return true;}
	return false;
}

function clsValidate_isSurNameSearch(sValue)
{
/*
	Notes: Plausi fuer die Suche nach Nachname mit Wildcards
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] fsp: 28.02.03: 
*/		
	var exp = /[^ a-zA-ZßäöüÄÖÜéèáà\-\&\+\?\*]/;    
	if (exp.test(sValue) == true){return false;}
	return true;	
}

function clsValidate_isErgebnisIDSearch(sValue)
{
/*
	Notes: Plausi fuer die Suche nach ErgebnisID mit Wildcards
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] fsp: 28.02.03: 
*/		
	var exp = /^([0-9\*\?]?[0-9\*\?]?[0-9\*\?])$/; //im Bereich von 0 bis 999 liegend
	if (exp.test(sValue) == false){return false;}
	return true;
}

function clsValidate_isDateSearch(sValue)
{
/*
	Notes: Plausi fuer die Suche nach Datum mit Wildcards
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] fsp: 26.02.03: 
*/	
	var sDate0 //gesäuberter String ohne Wildcards am Anfang
	var aDate
	var exp = /[^ 0-9\.\*\?]/; //zugelassene zeichen
	var expohneWildcards = /[\*\?]/;
	var expDoppelt = /[.][.]/;
	var expIstMonat =/^[0-1][\*\?]$/;
	var expTagOdMonat = /^[\*\?0-3][\*\?0-9]$/;
	var expIstWCvorne =/^[\*\?]+/;
	
	//Besteht die Eingabe aus korrekten Zeichen
	if (exp.test(sValue) == false)
	{
		//kein doppelter Punkt
		if (expDoppelt.test(sValue))
		{
			return false;
		}
		//keine Länge über 10
		if ((sValue.length > 10))
		{
			return false;
		}
		aDate = sValue.split(".");
		//verschiedene Suchmöglichkeiten werden kontrolliert
		switch (aDate.length)
		{
			case 3: //Tage, Monate und Jahre wurden eingegeben und werden geprüft
				//kontrolliere Tage
				if (pruefeTag(aDate[0]) == false){return false;}
				//kontrolliere Monate
				if (pruefeMonat(aDate[1]) == false){return false;}
				//kontrolliere Jahre
				if (pruefeJahr(aDate[2]) == false){return false;}
				//Standartplausi wird aufgerufen wenn keine Wildcards vorhanden sind
				if ((getZahlMitRichtigenStellen(aDate[0]) != false) && (getZahlMitRichtigenStellen(aDate[1]) != false) && (getZahlMitRichtigenStellen(aDate[2]) != false))
				{
					return clsValidate_isDate(getZahlMitRichtigenStellen(aDate[0]) + "." + getZahlMitRichtigenStellen(aDate[1]) + "." + getZahlMitRichtigenStellen(aDate[2]));
				}
				break;
				
			case 2: //2 Werte wurden eingegeben, unklaarer Datentyp
				{
					//entfernen vorstelliger Wildcards
					sDate0 = StringWithoutValueToBeginn(aDate[0],"*");
					sDate0 = StringWithoutValueToBeginn(sDate0,"?");
					
					//Länge prüfen
					if ((sDate0.length <= 2) && (aDate[1].length <= 4))
					{
						//Prüfe zweiten Wert:
						//der 2 Wert kann nur ein Jahr sein
						if ((isNaN(aDate[1]) == false && parseInt(aDate[1]) > 12) || (aDate[1].length > 2) || (expIstMonat.test(aDate[0])) || (aDate[1] == "00")) 
						{
							//kontrolliere Monate
							if (pruefeMonat(aDate[0]) == false){return false;}
							//ein Wildcard muss am Anfang stehen
							if (sDate0 == aDate[0]){return false;}
							//kontrolliere Jahre
							if (pruefeJahr(aDate[1]) == false){return false;}
							//vor dem Monat muss eine Wildcard stehen
							if (isNaN(aDate[0].charAt(0)) == false){return false};
						}
						else
						{
							//Prüfe ersten Wert
							//der 1 Wert kann nur ein Tag sein
							if (isNaN(aDate[0]) == false && parseInt(aDate[0]) > 12)
							{
								//kontrolliere Tage
								if (pruefeTag(aDate[0]) == false){return false;}
								//kontrolliere Monate
								if (pruefeMonat(aDate[1]) == false){return false;}
							}
						}
					}
					else //falsche Länge
					{
						return false;
					}
					break;
				}
			case 1: //1 Wert wurde eingegebe, unklaarer Datentyp
				{
					//entfernen vorstelliger Wildcards
					sDate0 = StringWithoutValueToBeginn(aDate[0],"*");
					sDate0 = StringWithoutValueToBeginn(sDate0,"?");
					
					//Länge prüfen
					if (sDate0.length <= 4)
					{
						//Prüfe nach Jahr
						if ((sDate0.length > 2) || (isNaN(aDate[0]) == false && parseInt(aDate[0]) > 31) || (aDate[0] == "00"))
						{
							//kontrolliere Jahre
							if (pruefeJahr(aDate[0]) == false){return false;}
							//ein Wildcard muss am Anfang stehen
							if (sDate0 == aDate[0]){return false;}
						}
						else
						{
							//Prüfe nach Tag oder Monat - d.h eigendlich nach Tag, da dessen Spezifikation die Monate übertrifft 
							if (pruefeTag(aDate[0]) == false){return false;}
						}
					}
					else // falsche Länge
					{
						return false;
					}
					break;
				}
		}
		return true;
	}
	else
	{
		return false;
	}

	
}

/*<<<<<<<<<<<
	Notes: Funktionen fuer die Suche nach Datum mit Wildcards
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] fsp: 26.02.03: 
*/
function StringWithoutValueToBeginn(sString,sValue)
{
	var aString
	var sZurueck = "";
	
	aString = sString.split(sValue);
	for (var i = 0; i < aString.length; i++)
	{
		if (aString[i].length > 0)
		{
			for (var z = i; z < aString.length; z++)
			{
				sZurueck = sZurueck + aString[z] + sValue;
			}
			break;
		}
	} 
	return sZurueck.substring(0,sZurueck.length-1);
}
	
function pruefeMonat(sValue)
{
	var expMonate = /^(0?[1-9]|1[0-2])$/;
	var expMonateMitWildcards =/^([\*\?0-1]?[\*\?0-9])$/
	var expohneWildcards = /[\*\?]/
	
	sValue = sValue.substring(sValue.length-2,sValue.length);
	
	if (sValue == "00")
	{
		return false;
	}
	else
	{
		if (expohneWildcards.test(sValue)) //mit Wildcards
		{
			if (expMonateMitWildcards.test(sValue) == false)
			{
				return false;
			}
		}
		else
		{
			if (expMonate.test(sValue) == false)	
			{
				return false;
			}			
		}
	}
	return true;
}

function pruefeJahr(sValue)
{
	var expohneWildcards = /[\*\?]/
	var expJahre = /^((20|19)?[0-9][0-9]?)$/;
	var expJahreMitWildcards =/^([\*\?12]?[\*\?90]?[\*\?0-9]?[\*\?0-9])$/
	
	sValue = sValue.substring(sValue.length-4,sValue.length);
	
	if (sValue.length > 0) //bei NULL wird automatisch * gesetzt
	{
		if (expohneWildcards.test(sValue)) //mit Wildcards
		{
			if 	(expJahreMitWildcards.test(sValue) == false)
			{
				return false;
			}		
		}
		else
		{
			if (expJahre.test(sValue) == false)
			{
				return false;
			}
		}
	}
	return true;
}

function pruefeTag(sValue)
{
	var expohneWildcards = /[\*\?]/
	var expTage = /^(0?[1-9]|[12][0-9]|3[01])$/;
	var expTageMitWildcards = /^([\*\?0-3]?[\*\?0-9])$/;

	if (expohneWildcards.test(sValue)) //mit Wildcards
	{
		if (expTageMitWildcards.test(sValue) == false)
		{
			return false;
		}
	}
	else // ohne Wildcards
	{
				
		if (expTage.test(sValue) == false)
		{
			return false;
		}
	}
	return true;	
}

function getZahlMitRichtigenStellen(sValue)
{
	//Wenn Widcard vorhanden oder automatisch an Datum gehängt wurde
	if (isNaN(sValue) == true || sValue.length == 3)
	{
		return false;
	}
	else
	{
		if (sValue.length == 2 || sValue.length == 4)
		{
			return sValue;
		}
		else //Ergänzung zu zwei Stellen
		{
			return "0" + sValue
		}
	}
}
//>>>>>>>>>>>>>>>

function clsValidate_isPLZSearch(sValue)
{
/*
	Notes: Plausi fuer die Suche nach PLZ's mit Wildcards
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] fsp: 19.02.03: 
*/	
	
	var exp = /[^ 0-9\*\?]/; //zugelassene zeichen
	if (exp.test(sValue) == false)
	{
		if ((sValue.length <= 5))
		{return true;}
		else
		{return false;}	
	}
	else
	{
		return false;
	}
}

function clsValidate_isDateSearch2(sValue)
{
/*
	Notes: Plausi fuer die Suche nach Datums mit Wildcards
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] fsp: 19.02.03: 
*/		
	var exp = /[^ 0-9\.\*\?]/; //zugelassene zeichen
	
	if (exp.test(sValue) == false)
	{
		if ((sValue.length <= 10))
		{return true;}
		else
		{return false};
	}
	else
	{
		return false;
	}
}

function clsValidate_isTimeSearch(sValue)
{
/*
	Notes: Plausi fuer die Suche nach Time mit Wildcards
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] fsp: 19.02.03: 
*/	
	var exp = /[^ 0-9\:\*\?]/; //zugelassene zeichen
	
	if (exp.test(sValue) == false)
	{
		if ((sValue.length <= 8))
		{return true;}
		else
		{return false};
	}
	else
	{
		return false;
	}
}


function clsValidate_isWildCard(sValue)
{
	exp = /[\*\?]/;
	
	//verlangt * oder ?
	
	if (exp.test(sValue))
	{return true;}
	else
	{return false;}
}


function clsValidate_isDate(sValue)
{
/*
	Notes: Kleine Plausi auf Datum: Jahresuntergenze: 1900 -obergrenze: 3000
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] ?
				[1] fsp: 14.02.03: Überprüfung der Ober- und Untergrenze
		
*/
	var aiJahr
	var iJahresZehner
	exp  = /(^[0-3][0-9].[0-1][0-9].\d{2}$)/ //Datum in logischen Grenzen mit jjjj
	exp2 = /(^[0-3][0-9].[0-1][0-9].\d{4}$)/ //Datum in logischen Grenzen mit jj
	if (exp.test(sValue) || exp2.test(sValue))
	{
		aiJahr = sValue.split(".");
		//die Tage mussen zwischen 1 und 31 liegen und die Monate zwischen 0 und 12
		if ((aiJahr[0] <= 0) || (aiJahr[0] > 31) || (aiJahr[1] <= 0) || (aiJahr[1] > 12))
		{
			return false;
		}
		//prueft die 31 iger Monate
		if (((aiJahr[1] == "01") || (aiJahr[1] == "03") || (aiJahr[1] == "05") || (aiJahr[1] == "07") || (aiJahr[1] == "08") || (aiJahr[1] == "10") || (aiJahr[1] == "12")) && (aiJahr[0] > 31)) 
		{
			return false;
		}
		// prueft die 30 iger Monate
		if (((aiJahr[1] == "04") || (aiJahr[1] == "06") || (aiJahr[1] == "09") || (aiJahr[1] == "11")) && (aiJahr[0] > 30))
		{
			return false;
		}
		//Überprüfe Jahresober- und -untergrenze 1900 und 2100
		if ((aiJahr[2].length ==4) && ((parseInt(aiJahr[2]) < 1900) || (parseInt(aiJahr[2]) > 2100)))
		{
			return false;
		}
		//Überprüfe Februar
		if (aiJahr[1] == "02")
		{
			if (aiJahr[2].length ==4)
			{
				iJahresZehner = parseInt(aiJahr[2].substring(2,4));
			}
			else
			{
				iJahresZehner = parseInt(aiJahr[2]);
			}
			if (iJahresZehner % 4 == 0)
			{
				if (parseInt(aiJahr[0]) > 29)
				{
					return false;
				}
			}
			else
			{
				if (parseInt(aiJahr[0]) > 28)
				{
					return false;
				}
			}
		}
		//ohne Fehler wird true zurückgegeben
		return true;
	}
	else
	{
		return false;
	}
	
}

function clsValidate_isTime(sValue, sFormat)
{
/*
	Notes: Plausi Zeit
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] ?
				[1] fsp: 14.02.03: Korrektur der Zeitangabe mit Sekunden von /^[2][0-4]\:[0-5][0-9]\:[0-6][0-9]$/ zu /^[2][0-4]\:[0-5][0-9]\:[0-5][0-9]$/ 
									da 69 Sekunden nicht möglich sind
		
*/

	switch (sFormat)
	{
		case "hh:mm":
		{
			exp  = /^[0-1][0-9]\:[0-5][0-9]$/ //von 00:00 bis 19:59
			exp1 = /^[2][0-4]\:[0-5][0-9]$/   //von 20:00 bis 24:59

			if (exp.test(sValue) || exp1.test(sValue))
				return true;
			else
				return false;
			break;
		}
		case "hh:mm:ss":
		{
			var exp  = /^[0-1][0-9]\:[0-5][0-9]\:[0-5][0-9]$/ //von 00:00:00 bis 19:59:69
			var exp1 = /^[2][0-4]\:[0-5][0-9]\:[0-5][0-9]$/   //von 20:00:69 bis 24:59:69

			if (exp.test(sValue) || exp1.test(sValue))
				return true;
			else
				return false;
			break;
		}
	}
}

function clsValidate_isAlphaText(sValue)
{
	var exp = /\d/; 
	
	//ist reiner Text ?
	//fsp: 14.02.03 :Aufgabe -> Kontrolle
	//ein Wert
	//keine Nummern
	//kein '
	
	if(sValue != "" && !exp.test(sValue) && clsValidate_isForbiddenLetter(sValue) == false)
		{return true;}	
	else
		{return false;}
}

function clsValidate_isPLZ(sValue)
{
	//wenn es eine positive Zahl ist UND 5 Stellen hat
	if ((isNaN(sValue) == false) && (sValue >= 0) && (sValue.length == 5) && (sValue != "00000") && (sValue.indexOf(" ") == -1))
		{return true;}
	else
		{return false;}
}

function clsValidate_isCurrency(sValue)
{
	var exp = /^\d+(\.|,)\d+$/;

	if (exp.test(sValue)) 
		return true;
	else
		return false;
}

function clsValidate_isNaN(sValue)
{
	//km:die js Function isNaN liefert für "" und für "    " ein false zrueck,
	//was bedeutet das er leerzeichen als zahl interpretiert. die Leerzeichen durch 
	//was anders zu ersetzen hat nicht geklappt. Hab keine zeit weiter damit zu spielen
	//fsp: 14.02.03 :Lösung eingebaut.
	
	if (isNaN(sValue) == true)
	{
		return true;
	}
	else
	{
		if ((sValue.length == 0) || (sValue.indexOf(" ") != -1))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
}

function clsValidate_isBLZ(sValue)
{
	//fsp: 14.02.03 :Aufgabe -> Kontrolle
	//1. ist eine Nummer
	//2. > 0
	//3. mit Laenge == 8
	
	if ((isNaN(sValue) == false) && (sValue > 0) && (sValue.length == 8) )
	{return true;}
	else
	{return false;}
}

function clsValidate_isAccountNumber(sValue)
{
	//fsp: 14.02.03 :Aufgabe -> Kontrolle
	//1. ist eine Nummer
	//2. >= 0
	//3. mit Laenge >= 10
	
	if (isNaN(sValue) == false && sValue > 0 && sValue.length <= 10)
		{return true;}
	else
		{return false;}
}


function clsValidate_isTelefon(sValue)
{
/*
	Notes: Kleine Plausi auf Telefonnummer: ruft clsValidate_isPhoneNumber auf um Inkonsistenz zu vermeiden
		Ursprungscode:
		var excl=/[a-zA-Z]/;
		if(sValue.search(excl) != -1)
			{return false;}	
		else
			{return true;}
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] ?
				[1] fsp: 14.02.03
		
*/
	return clsValidate_isPhoneNumber(sValue);

}

function clsValidate_isLetter(sValue)
{
// CustomerDetails.asp
// [0] 22.03.02 grd Implementierung

   var exp = /[^ a-zA-ZßäöüÄÖÜ\.]/;                   // z.B. Anrede, Titel, Adelstitel  
   
    //siehe isLetter2
   
   if (exp.test(sValue)) {
		return false;
	} else {
	   return true;
	}
}

function clsValidate_isLetter2(sValue)
{
// CustomerDetails.asp
// [0] 22.03.02 grd Implementierung

   var exp = /[^ a-zA-ZßäöüÄÖÜ\.\-]/;                 // z.B. Vorname
   
	//keine der Zeichen die außerhalb folgender Bereiche liegt:
	//1. kleine Buchstaben 
	//2. großen Buchstaben
	//3. .,-
   
   if (exp.test(sValue)) {
		return false;
	} else {
	   return true;
	}
}

function clsValidate_isSurName(sValue)
{
// CustomerDetails.asp
// [0] 22.03.02 grd Implementierung

	var exp = /[^ a-zA-ZßäöüÄÖÜéèáà\-\&\+]/;            
   
	//keine der Zeichen die außerhalb folgender Bereiche liegt:
	//1. kleine Buchstaben 
	//2. großen Buchstaben
	//3. -,`,´,&,+
   
   if (exp.test(sValue)) {
		return false;
	} else {
	   return true;
	}
}

function clsValidate_isStreet(sValue)
{
// CustomerDetails.asp
// [0] 22.03.02 grd Implementierung
// Da in einigen Tabellen die PLZ im Ort-Feld gespeichert wird, gilt diese Validierung auch für den Ort

	var exp = /[^ a-zA-Z0-9ßäöüÄÖÜ\.\-èéàá]/;     // Strasse, Ort
   
   	//keine der Zeichen die außerhalb folgender Bereiche liegt:
	//1. kleine Buchstaben 
	//2. großen Buchstaben
	//3. Nummern
	//4. -,`,´
   
   if (exp.test(sValue)) {
		return false;
	} else {
	   return true;
	}
}

function clsValidate_isZipCode(sValue)
{
/*
	Notes: Kleine Plausi auf PLZ: ruft clsValidate_isPLZ auf um Inkonsistenz zu vermeiden
		Ursprungscode:
		var exp = /[0-9]{5,5}/;                            // PLZ 
		if (exp.test(sValue)) {
		return true;
		} else {
		return false;
		}
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] 22.03.02 grd Implementierung
				[1] fsp: 14.02.03
*/
	return clsValidate_isPLZ(sValue);
}

function clsValidate_isPhoneNumber(sValue)
{
/*
	Notes: Kleine Plausi 
	
	Input: zu überprüfender Wert
	Output: Ergebnis
	
	History:	[0] 22.03.02 grd Implementierung
				fsp: [1]Erweiterung der Plausi von: /[^ 0-9\(\)\-\/\\]/ zu /[^ 0-9\(\)\-\/\\\+]/
					
*/
	var exp = /[^ 0-9\(\)\-\/\\\+]/;                     // Telefon, Fax, Handy
	var expAnfang = /^[ \(\+0-9]/;
	var expEnde = /[ \)0-9]$/;
	var expDoppelt = /[\(\)\-\/\\][\(\)\-\/\\]/;		
	   
	//keine der Zeichen die außerhalb folgender Bereiche liegt:
	//1. Nummern
	//2. (,),-,/,+
   
   if (exp.test(sValue)) {
		return false;
	} else 
	{
	   //fsp 17.2.03:
	   //Am Anfang: Leer,+,Zahl,(  
	   //Am Ende: Leer,),Zahl
	   if (expAnfang.test(sValue) && expEnde.test(sValue))
	   {
			//keine zwei Sonderzeichen hintereinander
			if (expDoppelt.test(sValue))
			{
				return false;
			}
			else
			{
				return true;
			}
	   }
	   else
	   {
			return false;
	   }
	}
}

function clsValidate_isMailAddress(sValue)
{
	var exp = /[a-zA-Z0-9][a-zA-Z0-9_\.-]{0,}[a-zA-Z0-9]@[a-zA-Z0-9][a-zA-Z0-9_\.-]{0,}[a-zA-Z0-9][\.][a-zA-Z0-9]{2,4}/;
	if (exp.test(sValue))
		return true;
	else
		return false;
}
//</script>