/***
*** Inhalt:
*** - jsY2K
*** - jsLastDayOfMonth
*** - jsIsDate
*** - jsIsTime
*** - jsDateCompare
*** - jsDateTimeCompare
*** - jsFmtDate
*** - jsGetDateOfKW1Monday
*** - jsDateAdd
*** - jsDateGetKW
*** - getISODay
*** - jsDateDiff
***/

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsY2K
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : pJahr  = Zu pruefendes Jahr
*** Returnwert: Jahr im 4st. Format.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion konvertiert alle Zahlen die kleiner 100 
***               sind in das Jahr 19xx und alle Zahlen deren Wert   
***              groesser gleich 100 ist, in das Jahr 2xxx. Zahlen die 
***              bereits 4st. sind, werden unberuehrt zurueckgegeben.
*** Created by  : 27.06.2000 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsY2K(pJahr) 
{ 
	xJahr = "" + pJahr;
	if( xJahr.length >= 4 )
		return pJahr; 
	return (pJahr < 100) ? pJahr + 1900 : (pJahr-100)+2000; 
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsLastDayOfMonth
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : m = Monat
***             j = Jahr im 4st. Format (JJJJ)
*** Returnwert: Tagesdatum des letzten Tag des angefragten Monats.
***             Im Faller eines Fehlers liefert die Funktion 0 zurueck.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion liefert das Tagesdatum des letzten Tages
***               des angefragten Monats zurueck. Im Falle eines Fehlers 
***               wird der Wert 0 zuruebergeben.
*** Created by  : 28.04.1999 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsLastDayOfMonth( m, j )
{
	var nMMax = 0;
	var bSchaltjahr = false;		

	if( j == null || j == "" )
		return 0;
		
	if( m == null || m == "" )
		return 0;
		
	j = jsY2K( j );

	// Auf Schaltjahr pruefen...
	// normalerweise true wenn durch 4 teilbar
	// weiteres Kriterium: muß auch durch 100 und 400 teilbar sein (Bsp: 1900
	// kein Schaltjahr obwohl durch 4 teilbar) 
	if( (j % 4 ) == 0 )
	{
		if(((j % 100) == 0) && ((j % 400) == 0))
		{
			bSchaltjahr = true;
		}
		else if(((j % 100) == 0) && ((j % 400) != 0))
		{
			bSchaltjahr = false;
		}
		else
		{
			bSchaltjahr = true;
		}
	}
		
	// Anzahl Tage im Monat ermitteln...
	if( m == 1 ) nMMax = 31;
	else if( m == 2 && bSchaltjahr )  nMMax = 29;
	else if( m == 2 && !bSchaltjahr )  nMMax = 28;
	else if( m == 3 )  nMMax = 31;
	else if( m == 4 )  nMMax = 30;
	else if( m == 5 )  nMMax = 31;
	else if( m == 6 )  nMMax = 30;
	else if( m == 7 )  nMMax = 31;
	else if( m == 8 )  nMMax = 31;		
	else if( m == 9 )  nMMax = 30;
	else if( m == 10 ) nMMax = 31;
	else if( m == 11 ) nMMax = 30;		
	else if( m == 12 ) nMMax = 31;

	return nMMax;
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsIsDate
*** Version   : JavaScript 1.1 
*** --------------------------------------------------------------------
*** Parameter : pDate  = Zu pruefendes Datum im Format T.M.JJJJ
***             Cutter = Trenner (Default:.)
*** Returnwert: True, wenn der Wert ein gueltiges Datum ist.
***             Andernsfals False.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion prueft ob der uebergebene Wert ein 
***               gueltiges Datum ist. Das verwendete Datumstrennzeichen 
***               wird im Parameter 'Cutter' uebergeben.
*** Created by  : 14.05.1999 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsIsDate(pDate, Cutter)
{
	var nMMax = 0;
	var sDate = "";
	var bSchaltjahr = false;

	if( Cutter == null || Cutter == "" )
		Cutter = ".";

	sDate = pDate;
	nToken = sDate.split( Cutter );

	if( nToken.length != 3 )
		return false;

	nToken[0] = parseFloat( nToken[0] );
	nToken[1] = parseFloat( nToken[1] );
	nToken[2] = parseFloat( nToken[2] );
/*	For debug:
alert( "nToken[0]:"+nToken[0]+
		 "\nnToken[1]:"+nToken[1]+
		 "\nnToken[2]:"+nToken[2]+
		 "\nnMMax:"+nMMax );
return false;
*/
	// Auf gueltige Zahlen pruefen...
	if( isNaN( nToken[0] ) == true )
		return false;
	if( isNaN( nToken[1] ) == true )
		return false;
	if( isNaN( nToken[2] ) == true )
		return false;
			
	// Jahreseingabe pruefen... 
	nToken[2] = jsY2K( nToken[2] );

	// Monatseingabe pruefen...
	nMMax = jsLastDayOfMonth( nToken[1], nToken[2] );
	if( nMMax == 0 )
		return false;

/*	For debug:
alert( "nToken[0]:"+nToken[0]+
		 "\nnToken[1]:"+nToken[1]+
		 "\nnToken[2]:"+nToken[2]+
		 "\nnMMax:"+nMMax );
*/

	// Tageseingabe pruefen...
	if( nToken[0] < 1 || nToken[0] > nMMax )
		return false;

	// Alle Tests erfolgreich, also...
	return true;
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsIsTime
*** Version   : JavaScript 1.1 
*** --------------------------------------------------------------------
*** Parameter : pTime  = Zu pruefende Zeit im Format HH:MM
***             Cutter = Trenner (Default: :)
*** Returnwert: True, wenn der Wert eine gueltige Uhrzeit ist.
***             Andernsfals False.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion prueft ob der uebergebene Wert eine 
***               gueltige Uhrzeit ist. Das verwendete Trennzeichen 
***               wird im Parameter 'Cutter' uebergeben.
*** Created by  : 24.08.2001 Schaufler Andreas
*** Updated by  : 
***********************************************************************/
function jsIsTime(pTime, Cutter)
{
	if( Cutter == null || Cutter == "" )
		Cutter = ":";

	sTime = pTime;
	nToken = sTime.split( Cutter );

	if( nToken.length != 2 )
		return false;

	//Minuteneingabe muß 2-stellig sein	
	
	if (nToken[1].length != 2)
		return false;		
		
	if (nToken[1].substr(0,1) == '0')
		nToken[1] = nToken[1].substr(1,2);
		
	nToken[0] = parseFloat( nToken[0] );
	nToken[1] = parseFloat( nToken[1] );

/*	//	For debug:
	alert( "nToken[0]:" + nToken[0] + "\nnToken[1]:" + nToken[1]);
	return false;  */
	
	// Auf gueltige Zahlen pruefen...
	if( (isNaN( nToken[0] ) == true) || (nToken[0] < 0 || nToken[0] > 23) )
		return false;
	if( (isNaN( nToken[1] ) == true) || (nToken[1] < 0 || nToken[1] > 59) )
		return false;	

	// Alle Tests erfolgreich, also...
	return true;
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsDateCompare
*** Version   : JavaScript 1.1 
*** --------------------------------------------------------------------
*** Parameter : pDate1  = 1.Zu pruefendes Datum im Format T.M.JJJJ
***             Cutter1 = Datumszahlentrenner fuer Datum 1 (Default:.)
***             pDate2  = 2.Zu pruefendes Datum im Format T.M.JJJJ
***             Cutter2 = Datumszahlentrenner fuer Datum 2 (Default:.)
*** Returnwert: 0, wenn die Werte identisch.
***             1, wenn Wert1 kleiner Wert2 ist.
***             2, wenn Wert1 groesser Wert2 ist.
***             Im Falle eines Fehlers wird der Wert -1 zurueckgeliefert
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion vergleicht zwei Datumswerte miteinander
***               und liefert je nach Ergebnis den Wert 0, 1 oder 2 
***               zurueck. wird im Parameter 'Cutter' uebergeben.
*** Created by  : 14.05.1999 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsDateCompare(pDate1,Cutter1,pDate2,Cutter2 )
{
	var sDate1 = "";
	var sDate2 = "";
		
	sDate1 = pDate1;
	sDate2 = pDate2;
	
	if( sDate1 == null || sDate1 == "" ) return -1;
	if( sDate2 == null || sDate2 == "" ) return -1;

	if( Cutter1 == "" ) Cutter1 = ".";
	if( Cutter2 == "" ) Cutter2 = ".";
				
	nToken1 = sDate1.split( Cutter1 );
	nToken1[0] = parseFloat( nToken1[0] );
	nToken1[1] = parseFloat( nToken1[1] );
	nToken1[2] = parseFloat( nToken1[2] );

	// Auf gueltige Zahlen pruefen...
	if( isNaN( nToken1[0] ) == true ) return -1;
	if( isNaN( nToken1[1] ) == true ) return -1;
	if( isNaN( nToken1[2] ) == true ) return -1;
			
	// Jahreseingabe pruefen... 
	nToken1[2] = jsY2K( nToken1[2] );
	
	nToken2 = sDate2.split( Cutter2 );
	nToken2[0] = parseFloat( nToken2[0] );
	nToken2[1] = parseFloat( nToken2[1] );
	nToken2[2] = parseFloat( nToken2[2] );

	// Auf gueltige Zahlen pruefen...
	if( isNaN( nToken2[0] ) == true ) return -1;
	if( isNaN( nToken2[1] ) == true ) return -1;
	if( isNaN( nToken2[2] ) == true ) return -1;

	// Jahreseingabe pruefen... 
	nToken2[2] = jsY2K( nToken2[2] );

	// Datumswert 1 pruefen...
	if( !jsIsDate( nToken1[0]+"."+nToken1[1]+"."+nToken1[2], "." ) )
		return -1;

	// Datumswert 2 pruefen...
	if( !jsIsDate( nToken2[0]+"."+nToken2[1]+"."+nToken2[2], "." ) )
		return -1;
		
	// Relation der zwei Datumswerte untereinander pruefen...		
	if( nToken1[2] < nToken2[2] ) 
		return 1; // Jahr 1 < Jahr 2

	if( nToken1[2] > nToken2[2] ) 
		return 2; // Jahr 1 > Jahr 2

	if( nToken1[1] < nToken2[1] ) 
		return 1; // Monat 1 < Monat 2;

	if( nToken1[1] > nToken2[1] ) 
		return 2; // Monat 1 > Monat 2;

	if( nToken1[0] < nToken2[0] ) 
		return 1; // Tag 1 < Tag 2

	if( nToken1[0] > nToken2[0] ) 
		return 2; // Tag 1 > Tag 2
	
	return 0; // Datum 1 == Datum 2
}

/***********************************************************************
*** Funktion    : chkDateTimeRelation
*** Copyright by: Media Solutions GmbH
*** Erstellt am : 05.09.2002 Clemens Kolbenschlag
*** Editiert am : 
***********************************************************************/
function jsDateTimeCompare( sVDate, sVTime, sBDate, sBTime )
{
	sVDate = jsFmtDate(sVDate, ".", "D.M.YYYY", "DD.MM.YYYY");
	sBDate = jsFmtDate(sBDate, ".", "D.M.YYYY", "DD.MM.YYYY");

	dtVZeitpunkt = new Date( parseFloat(sVDate.substring(6,10)),	// Jahr
						 		   (parseFloat(sVDate.substring(3,5))-1),	// Monat
							  		 parseFloat(sVDate.substring(0,2)), 	// Tag
									 parseFloat(sVTime.substring(0,2)),		// Stunde
									 parseFloat(sVTime.substring(3,5)),		// Minute
									 0 ); 											// Sekunde

	dtBZeitpunkt = new Date( parseFloat(sBDate.substring(6,10)),	// Jahr
						 		   (parseFloat(sBDate.substring(3,5))-1),	// Monat
							  		 parseFloat(sBDate.substring(0,2)), 	// Tag
									 parseFloat(sBTime.substring(0,2)),		// Stunde
									 parseFloat(sBTime.substring(3,5)),		// Minute
									 0 ); 											// Sekunde

	if( dtVZeitpunkt.getTime() > dtBZeitpunkt.getTime() )
		return 1;
	else if( dtVZeitpunkt.getTime() == dtBZeitpunkt.getTime() )
		return 0;
	else
		return (-1);	
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsFmtDate
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : sDate  = Zu formatierender String mir Datum      
***             Cutter = Datumstrenner 
***             sIn    = Quell-Format {YYYYMMDD|D.M.YYYY}
***             sout   = Ziel-Format {DD.MM.YYYY|YYYYMMDD}
*** Returnwert: Das formatierte Datum.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion formatiert den übergebenen Datumsstring,
***               der das Quell-Format IN besitzt, in das angegebene
***               Zielformat OUT.
*** Created by  : 14.05.1999 Clemens Kolbenschlag
*** Updated by  : 05.09.2002 Clemens Kolbenschlag 
***********************************************************************/
function jsFmtDate(sDate, Cutter, sIn, sOut)
{
	var d = 0;
	var m = 0;
	var y = 0;
	var xDate = "";

	// -----------------------------------------------------------------------
	// In: YYYYMMDD --> Out: DD.MM.YYYY
	if( sIn == "YYYYMMDD" )
	{
		if( sOut =="DD.MM.YYYY" )
		{
			y = parseFloat(sDate.substring(0,4));
			m = parseFloat(sDate.substring(4,6));
			d = parseFloat(sDate.substring(6,(sDate.length)));

			if( d < 10 )	xDate = xDate + "0";
			xDate = xDate +""+ d + Cutter;
			if( m < 10 )	xDate = xDate + "0";
			xDate = xDate +""+ m + Cutter;
			xDate = xDate +""+ jsY2K(y);
		}
	}
	// -----------------------------------------------------------------------
	// In: xD.xM.YYYY --> Out: DD.MM.YYYY 
	// In: xD.xM.YYYY --> Out: YYYYMMDD   
	else if( sIn == "D.M.YYYY" )
	{
		nToken = sDate.split( Cutter );
		d = parseFloat( nToken[0] );
		m = parseFloat( nToken[1] );
		y = parseFloat( nToken[2] );

		if( sOut =="DD.MM.YYYY" )
		{
			if( d < 10 )	xDate = xDate + "0";
			xDate = xDate +""+ d + Cutter;
			if( m < 10 )	xDate = xDate + "0";
			xDate = xDate +""+ m + Cutter;
			xDate = xDate +""+ jsY2K(y);
		}
		else if( sOut =="YYYYMMDD" )
		{
			xDate = ""+ jsY2K(y);
			if( m < 10 )	xDate = xDate + "0";
			xDate = xDate +""+ m;
			if( d < 10 )	xDate = xDate + "0";
			xDate = xDate +""+ d;
		}
	}
	// -----------------------------------------------------------------------
	// In: ?? --> Out: ??
	else
		xDate = sDate;

	return xDate;
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsGetDateOfKW1Monday
*** Version   : JavaScript 1.0
*** --------------------------------------------------------------------
*** Parameter : nYear = Jahr zu dem der Montag ermittelt werden soll.
***             dtReturn = Datum des Montags in der KW 1.(=Returnwert) 
*** Returnwert: Das Datum des Montags in der KW 1.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion liefert das Datum des Montages aus der 
***               1. KW zurück.
*** Created by  : 24.07.2001 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsGetDateOfKW1Monday( nYear, dtReturn )
{
	var dtKW1 = new Date(nYear,0,4);
	
	// Wochentag des 4.Januar des Folgejahres... 
	var nDayOfWeek = dtKW1.getDay();

	var nDayDiff = 0;
	switch( nDayOfWeek )
	{
		// Differenz zum Montag der KW 1 des Jahres... 
		case 0: nDayDiff = -6; // Sonntag
				  break;
		case 1: nDayDiff = 0;  // Montag		
				  break;
		case 2: nDayDiff = -1; // Dienstag		
				  break;
		case 3: nDayDiff = -2; // Mittwoch		
				  break;
		case 4: nDayDiff = -3; // Donnerstag		
				  break;
		case 5: nDayDiff = -4; // Freitag		
				  break;
		case 6: nDayDiff = -5; // Samstag		
		 		  break;
	}

	// Datum auf den Montag der KW 1 setzen... 
	var dtMonday1KW = new Date();
	dtMonday1KW = jsDateAdd( "d", nDayDiff, dtKW1 );

	dtReturn.setTime(dtMonday1KW);
	return( dtReturn );
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsDateAdd
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : sDatePart = Konstante "d" für Day
***             nNumber = Wert der addiert/subtrahiert wird.
***             dtDate  = Zu veränderndes Datum.
*** Returnwert: Das neue Datum.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion addiert zu dem Datum (dtDate) den in    
***               nNumber spezifizierten Zeitinterval hinzu. Der Para-    
***               meter sDatePart bestimmt dabei das Datumsattribut.
*** Created by  : 24.07.2001 Clemens Kolbenschlag
*** Updated by  : 
***********************************************************************/
function jsDateAdd(sDatepart, nNumber, dtDate)
{
	dtJetzt = dtDate.getTime();
	dtReturn = new Date();
	
	if( sDatepart == "d" ) // Tage
		dtDann = dtJetzt + ((nNumber)*24*60*60*1000);
	else if( sDatepart == "n" ) // Minuten
		dtDann = dtJetzt + ((nNumber)*60*1000);
	else
		dtDann = dtJetzt;

	dtReturn.setTime(dtDann);
	return( dtReturn );
}

/***********************************************************************
*** Copyright : Media Solutions GmbH, Munich
*** Funktion  : jsDateGetKW
*** Version   : JavaScript 1.0 
*** --------------------------------------------------------------------
*** Parameter : dtDate = Datum zu dem die KW ermittelt werden soll.
*** Returnwert: Die Nummer der KW.
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion ermittelt die KW zu dem als Parameter   
***               übergebenen Datum und liefert diese zurück.
***               Die Variable nSTDiff ist für den Ausgleich der Zeit bei 
***               möglicher Sommer-/Winterzeitumstellung.
*** Created by  : 24.07.2001 Clemens Kolbenschlag
*** Updated by  : 02.05.2003 Peer Wermuth
***********************************************************************/
function jsDateGetKW( dtDate )
{
	dtKW1Monday = new Date();
	jsGetDateOfKW1Monday( jsY2K(dtDate.getYear()), dtKW1Monday );

	dtKW1MondayX = new Date(); 
	jsGetDateOfKW1Monday( jsY2K((dtDate.getYear()+1)), dtKW1MondayX );

	nDate1 = dtKW1Monday.getTime(); 		// Basis in Millisekunden
	nDate1x = dtKW1MondayX.getTime(); 	// Basis+1 in Millisekunden
	nDate2 = dtDate.getTime(); 			// Ziel in Millisekunden

	if( nDate2 < nDate1 ) 	// Datum liegt vor der Basis
	{
		jsGetDateOfKW1Monday( jsY2K((dtDate.getYear()-1)), dtKW1Monday );
		nDate1 = dtKW1Monday.getTime(); 	// in Millisekunden
	}				
	else if( nDate2 >= nDate1x ) // Ziel liegt bereits im nächsten Jahr
	{
		return 1;
	}

	nSTDiff = ( ( dtDate.getTimezoneOffset() - dtKW1Monday.getTimezoneOffset() ) * -1 ) * 60 * 1000;

	nDiffMSec = nDate2 - nDate1 + nSTDiff;	// in Millisekungen
	nDiffTage = nDiffMSec/24/60/60/1000;	// in Tagen

	nKW = Math.floor(nDiffTage/7)+1;
	return(nKW);
}

/***********************************************************************
*** Funktion    : getISODay (ISO8601:1998)
*** Copyright by: Media Solutions GmbH
*** Erstellt am : 24.07.2001 Clemens Kolbenschlag
*** Editiert am :
***********************************************************************/
function getISODay( nID )
{
	switch( nID )
	{
		case 1: return 0; break; // Montag  	-> 0     
		case 2: return 1; break; // Dienstag 	-> 1
		case 3: return 2; break; // Mittwoch 	-> 2
		case 4: return 3; break; // Donnerstag -> 3
		case 5: return 4; break; // Freitag 	-> 4
		case 6: return 5; break; // Samstag 	-> 5
		case 0: return 6; break; // Sonntag 	-> 6     
	}
}

/***********************************************************************
*** Funktion    : jsDateDiff
*** Copyright by: Media Solutions GmbH
*** --------------------------------------------------------------------
*** Parameter : dtDate1 = Erstes Datum der Zeitspanne
***				 dtDate2 = Erstes Datum der Zeitspanne
*** Returnwert: Differenz zwischen den beiden Daten in der angegebenen
***				 Einheit
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion vergleicht zwei Datumswerte 
***					im Format dd.mm.yyyy und liefert die Differenz in der 
***					in pUnit übergebenen Einheit zurück 
***					("d" für Tage, "h" für Stunden, "i" für Minuten 
***					und "s" für Sekunden, default Tage)
*** --------------------------------------------------------------------
*** Erstellt am : 14.11.2002 Andreas Berleth
*** Editiert am :
***********************************************************************/
function jsDateDiff(dtDate1, dtDate2, pUnit)
{
	// Daten in Timestamps umwandeln ...
	dtDate1 = jsUnixTime(dtDate1);
	dtDate2 = jsUnixTime(dtDate2);
	
	// Daten subtrahieren
	dtDiff = dtDate2 - dtDate1;
	
	// Millisekunden -> Sekunden#
	dtDiff = dtDiff/1000;
	
	//Ausgabe je nach Parameter
	if (pUnit == "s")
	{
		return dtDiff;
	}
	dtDiff = dtDiff/60;
	if (pUnit == "m")
	{
		return dtDiff;
	}
	dtDiff = dtDiff/60;
	if (pUnit == "h")
	{
		return dtDiff;
	}
	dtDiff = dtDiff/24;
	return dtDiff;
}

/***********************************************************************
*** Funktion    : jsUnixTime
*** Copyright by: Media Solutions GmbH
*** --------------------------------------------------------------------
*** Parameter : dtDate = Datum das in ein UNIX-Timestamp umgewandelt 
***				 werden soll
*** Returnwert: UNIX-Timestamp
*** --------------------------------------------------------------------
*** Beschreibung: Die Funktion erzeugt aus einem gegebenen Datum ein
***					UNIX-Timestamp
*** --------------------------------------------------------------------
*** Erstellt am : 14.11.2002 Andreas Berleth
*** Editiert am :
***********************************************************************/
function jsUnixTime(dtDate)
{
	aDate = dtDate.split(".");
	aDate[1]--;
	aDate.reverse();
	aDate.join(",");
	dtUnix = eval("new Date(" + aDate+ ")");
	return dtUnix;
}