//Code JavaScript concernant l'interface Web du projet 
//Auteurs
//	Paul Peltier , Stéphane Bosserdet
//Date de création
//	28/11/2000

//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
//Fonction standard - All Projects
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------

//Methode de test de présence d'un champs dans le document courant renvoie TRUE / FALSE
//Paramètre
//	strFIELDNAME - le nom du champ à chercher
//Auteur
//	Stéphane Bosserdet
//Date de création
//	19/06/2001
function fieldExists(
	formValue,
	strFieldName)
{
	if (formValue == null)
		return(false);
	
	if (typeof(formValue) == "undefined")
		return(false);
	
	if (typeof(formValue.elements[strFieldName]) == "undefined")
		return(false);
	
	return(true);
}

//--------------------------------------------------------------------------------------------------------------

//Procédure de test du browser
//Retour
//	boolean - le browser peut lancer l'interface d'admin
//Auteur
//	Paul Peltier
//Date de création
//	28/11/2000
function isBrowserValid()
{
//	var strVersion;
	var iAppName;
	var iAppVersion;
	var boolReturn;

	boolReturn = true;
	
	//Détection du type d'éxécution (Environnement de base)
	iAppName = navigator.appName.indexOf("Netscape");
	if (iAppName > -1)
		boolReturn = false;

	iAppVersion = navigator.appVersion.indexOf("5");
	if (iAppVersion < 0)
		boolReturn = false;
	
	return(boolReturn);
}

//--------------------------------------------------------------------------------------------------------------

//Met à jour les champs pour un type de formulaire
//Paramètre
//	docValue - le document à mettre à jour
//	tblValues - la table de valeur (attention à 2 dim.)
//		pour le format voir applet Java fct getFieldValuesFromUNID
//Auteur
//	Paul Peltier
//Date de création
//	27/11/2001
function integrateValues(
	formValue,
	tblValues)
{
	var i;
	var strFieldName;
	var strFieldValue;
	var tblValues;

	for(i = 0; i < tblValues.length; i++)
	{
		strFieldName = tblValues[i][0];
		strFieldValue = tblValues[i][1];
		
		if (fieldExists(formValue, strFieldName))
			formValue.elements[strFieldName].value = 
				strFieldValue;
	}
}

//--------------------------------------------------------------------------------------------------------------

//Convertit un vecteur Java sous forme d'array
//Paramètre
//	oValues - le vecteur à translater
//Paramètre
//	Object - un tableau si la donnée de départ est un vecteur, une chaîne si la donnée de départ n'est as un vecteur.
//Auteur
//	Paul Peltier
//Date de création
//	01/02/2002
function convertVectorToArray(
	oValues)
{
	var i;
	var iValuesSize;
	var oBeforeTemps;
	var oAfterTemps;
	var oReturns;

	iValuesSize = appAppletDesignBase.sizeOf(oValues);
	
	if (iValuesSize < 0)
	{
		//Ce n'est pas un vecteur on le renvoie tel quel (cela doit ête une chaîne ou un null)
		return(oValues);
	}

	oReturns = new Array();
	for(i = 0; i < iValuesSize; i++)
	{
		oBeforeTemps = oValues.elementAt(i);
		oAfterTemps = 
			convertVectorToArray(
				oBeforeTemps);
		
		oReturns.push(oAfterTemps);
	}
	
	return(oReturns);
}

//--------------------------------------------------------------------------------------------------------------

//Construit un vecteur de valeurs type String à partir d'une chaîne.
//Paramètre
//	strValue la chaîne à analyser et à transformer.
//	strTokenizer la caractère de troncature.
//Retour
//	Vector - le vecteur cherchée.
//Auteur
//	Paul Peltier
//Date de création
//	08/04/2002
function getArrayFromString(
	strValue,
	strTokenizer)
{
	var arReturns;
	var strTemp;
	var iValue;
	var iTemp;
	var i;

	//Test de la valeur récupérée
	if ((strValue == null) || 
		(strValue == ""))
		return(strValue);

	//Création du tokenstring
	arReturns = new Array();
	iValue = 0;

	while (iValue > -1)
	{
		//Lecture de la nouvelle valeur
		iTemp = iValue;
		iValue = strValue.indexOf(strTokenizer, iValue);
		if (iValue > -1)
		{
			strTemp = strValue.substring(iTemp, iValue);
			iValue++;
		}
		else
			strTemp = strValue.substring(iTemp);

		arReturns.push(strTemp);
	}

	return(arReturns);
}

//--------------------------------------------------------------------------------------------------------------

//Met à zéro les champs de correction d'un tableau de nom de champs.
//Paramètre
//	formValue - le contexte sur le formulaire.
//	tblFieldNames - le tableau des noms de champs.
//	Paul Peltier
//Date de création
//	05/04/2002
function removeValues(
	formValue,
	tblFieldNames)
{
	var i;
	var strFieldName;
	var strFieldCorrectName;

	if (tblFieldNames != null)
		for(i = 0; i < tblFieldNames.length; i++)
		{
			strFieldName = tblFieldNames[i];
			strFieldCorrectName = strFieldName + "_c";
			if (fieldExists(formValue, strFieldCorrectName))
				formValue.elements[strFieldCorrectName].value = "";
		}
}

//--------------------------------------------------------------------------------------------------------------
//Récupération des messages d'erreur en fonction de la langue utilisée dans les formulaires.
//Paramètres :
//	numConstErrorMsg - Constante permettant de répérer le type de message d'erreur (champs obligatoire, type incorrect,...)
//	strLanguage - Langue assosocié au formulaire.
//	strTypeField - clé correspondant au message d'erreur
//Auteur :
//	Cosmosbay (PIB)
//Date de création :
//	15/12/2003
function getErrorMsg (
	numConstErrorMsg,
	strLanguage,
	strTypeField)
	
{
	var i;
	var j;
	
	var tbl0;
	var tbl1;
	var msgReturn
		
	//Récupération des données
	tbl0 = getSystemInfo(
			"message_erreur_langues",
			numConstErrorMsg);
	
	//Récupération dans le tableau du message d'erreur en fonction des paramétres.
	for(i = 0; i < tbl0.length; i++){
		//alert ("tbl 0 ("+i+")= " + tbl0[i]);
		if (strLanguage == tbl0[i][0]) {
			tbl1=tbl0[i][1]
			for(j = 0; j < tbl1.length; j++){
				if (strTypeField == tbl1[j][0])
				msgReturn = tbl1[j][1]
			}
		}
	}
	//alert ("msgReturn = " + msgReturn);
	return(msgReturn);
}

//--------------------------------------------------------------------------------------------------------------
//Validation des champs obligatoires.
//Paramètre
//	formValue - le contexte sur le formulaire.
//	tblObligFieldNames - le tableau des noms de champs obligatoires.
//Auteur
//	Paul Peltier
//Date de création
//	13/12/2001
function validObligFields(
	formValue,
	tblObligFieldNames,
	strErrMsg)
{
	var i;
	var j;
	var strObligFieldNames;
	var strObligFieldCorrectName;
	var boolReturn;
	var boolTemp;
	
	boolReturn = false;

	if (tblObligFieldNames == null)
		return(boolReturn);

	for(i = 0; i < tblObligFieldNames.length; i++)
	{
		strObligFieldNames = tblObligFieldNames[i];
		strObligFieldCorrectName = strObligFieldNames + "_c";
		if (fieldExists(formValue, strObligFieldNames))
		{
			if (formValue.elements[strObligFieldNames].value == "")
			{
				boolReturn = true;
				
				if (fieldExists(formValue, strObligFieldCorrectName))
					formValue.elements[strObligFieldCorrectName].value = strErrMsg;
			}
			else
			{
				if (typeof(formValue.elements[strObligFieldNames].value) == "undefined")
				{
					//Cas d'autres type de contrôle type checkbox
					boolTemp = false;;
					for (j = 0; j < formValue.elements[strObligFieldNames].length; j++)
					{
						if (formValue.elements[strObligFieldNames][j].checked)
						{
							boolTemp = true;
							break;
						}
					}
					
					if (!boolTemp)
					{
						boolReturn = true;
						if (fieldExists(formValue, strObligFieldCorrectName))
							formValue.elements[strObligFieldCorrectName].value = strErrMsg;
					}
				}
			}
			
		}
	}
	return(boolReturn);
}

//--------------------------------------------------------------------------------------------------------------

//Validation des champs numériques
//Paramètre
//	strForm - le nom de la notion abordée
//Auteur
//	Paul Peltier
//Date de création
//	13/12/2001
function validNumericFields(
	formValue,
	tblNumericFieldNames,
	strErrMsg)
{
	var arValues;
	var strNumericFieldName;
	var strNumericFieldCorrectName;
	var strValue;
	var boolReturn;
	var iTemp;
	var i;
	var j;
	
	boolReturn = false;
	
	if (tblNumericFieldNames == null)
		return(boolReturn);
	
	for(i = 0; i < tblNumericFieldNames.length; i++)
	{
		strNumericFieldName = tblNumericFieldNames[i];
		strNumericFieldCorrectName = strNumericFieldName + "_c";
		
		if (fieldExists(formValue, strNumericFieldName))
		{
			//Test sur plusieurs entrées
			strTemp = formValue.elements[strNumericFieldName].value;
			arValues = 
				getArrayFromString(
				strTemp,
				"\n");
			iTemp = 0;
			
			for (j = 0; j < arValues.length; j++)
			{
				strValue = arValues[j];
				
				if ((strValue != null) && (strValue != ""))
				{
					if (!parseFloat(strValue))
					{
						iTemp++;
						boolReturn = true;
					}
				}
			}

			if ((iTemp > 0) && 
				(fieldExists(formValue, strNumericFieldCorrectName)))
			{
				formValue.elements[strNumericFieldCorrectName].value = strErrMsg;
				
				if (arValues.length > 1)
				{
					formValue.elements[strNumericFieldCorrectName].value = 
						formValue.elements[strNumericFieldCorrectName].value + 
						" : " + 
						iTemp + 
						" entrée(s) sur " + 
						arValues.length;
				}
			}
		}
	}
	return(boolReturn);
}

//--------------------------------------------------------------------------------------------------------------

//Test la validité d'une adresse mail
//Paramètre
//	strValue - l'adresse mail
//Auteur
//	Paul Peltier
//Date de création
//	13/12/2001
function checkMailAddress(
	strValue)
{
	var strTemp;
	var strTemp1;
	var strInit;
	var iValue;
	
	//Chaine de type D__@__.__F
	strInit = new String(strValue);

	//Vérification : D__F contient un @
	iValue = strInit.indexOf("@");
	if (iValue < 0)
		return(false);
	
	//Chaîne D__@
	strTemp = strInit.substr(0, iValue);

	//Vérification : D__@ non vide
	iValue = strTemp.length;
	if (iValue == 0)
		return(false);

	//Chaîne @__F
	strTemp = strInit.substr(iValue + 1, strInit.length - 1);

	//Vérification : @__F non vide
	iValue = strTemp.length;
	if (iValue == 0)
		return(false);

	//Vérification : @__F contient pas d'autre @
	iValue = strTemp.indexOf("@");
	if (iValue > 0)
		return(false);
		
	//Vérification : @__F contient un .
	iValue = strTemp.indexOf(".");
	if (iValue < 0)
		return(false);

	//Chaîne @__.
	strTemp1 = strTemp.substr(0, iValue);

	//Vérification : @__. non vide
	iValue = strTemp1.length
	if (iValue == 0)
		return(false);

	//Chaîne .__F
	strTemp1 = strTemp.substr(iValue + 1, strTemp.length - 1);

	//Vérification : @__. non vide
	iValue = strTemp1.length;
	if (iValue == 0)
		return(false);

	//Vérification : @__F contient pas d'autre @
	iValue = strTemp1.indexOf("@");
	if (iValue > 0)
		return(false);
		
	return(true);
}

//--------------------------------------------------------------------------------------------------------------

//Validation des champs mail
//Paramètre
//	strForm - le nom de la notion abordée
//Auteur
//	Paul Peltier
//Date de création
//	13/12/2001
function validMailFields(
	formValue,
	tblMailFieldNames,
	strErrMsg)
{
	var strMailFieldName;
	var strMailFieldCorrectName;
	var strValue;
	var strTemp;
	var arValues;
	var boolReturn;
	var iTemp;
	var i;
	var j;
	
	boolReturn = false;
	
	if (tblMailFieldNames == null)
		return(boolReturn);
	
	for(i = 0; i < tblMailFieldNames.length; i++)
	{
		strMailFieldName = tblMailFieldNames[i];
		strMailFieldCorrectName = strMailFieldName + "_c";
		
		if (fieldExists(formValue, strMailFieldName))
		{
			//Test sur plusieurs entrées
			strTemp = formValue.elements[strMailFieldName].value;
			arValues = 
				getArrayFromString(
				strTemp,
				"\n");
			iTemp = 0;
			
			for (j = 0; j < arValues.length; j++)
			{
				strValue = arValues[j];
				
				if ((strValue != null) &&
					(strValue != "") &&
					!checkMailAddress(strValue))
				{
					iTemp++;
					boolReturn = true;
				}
			}

			if ((iTemp > 0) && 
				(fieldExists(formValue, strMailFieldCorrectName)))
			{
				formValue.elements[strMailFieldCorrectName].value = strErrMsg;

				if (arValues.length > 1)
				{
					formValue.elements[strMailFieldCorrectName].value = 
						formValue.elements[strMailFieldCorrectName].value + 
						" : " + 
						iTemp + 
						" entrée(s) sur " + 
						arValues.length;
				}
			}
		}
	}
	
	return(boolReturn);
}

//--------------------------------------------------------------------------------------------------------------

//Validation d'une date composée de 3 champs (jour, mois et année)
//Paramètres
//	formValue - l'objet formulaire de la page
//	tblDateFildNames - tableau contenant le ou les champs à valider.
//  		(C'est le nom commun aux trois champs représentant une date (ex: naissance_date, naissance_jour, naissance_annee) 
//Auteur
//	Pierre Bazydlo
//Date de création
//	19/03/2003

function isDateValid(jour,mois,an) {
	var day = parseInt(jour,10);
	var month = parseInt(mois,10);
	var year = parseInt(an,10);
	y0 = true;
	m0 = true;
	j0 = true;

	if (isNaN(year)) y0 = false;
	if (isNaN(month)) m0 = false;
	if (isNaN(day)) j0 = false;

	dte = new Date();
	an = dte.getYear();
	limite_sup = 1900 + an - 13;

	if (year < 1880) {y0 =  false;}
	if (year < 1880 || year >= limite_sup) {y0 =  false;}
	if (month < 1 || month > 12) {m0 = false;};
	
	var nbday;
	if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) nbday = 31;
	else if (month != 2) nbday = 30;
	else {
		if (year < 100)	nbday = 29;
		else {
			if ((year % 400 == 0) || (year % 4 == 0)) nbday = 29;
			else nbday = 28;
		}
	}
	if ((month > 0 && month < 13) && (day < 1 || day > nbday)) j0 = false;

	return (j0 && m0 && y0);
}

function valideDateFields (
			formValue,
			tblDateFieldNames,
			strErrMsg)
{
	var strDateFieldName;
	var strDateFieldCorrectName;
	
	var strDateFieldDay;
	var strDateFieldMonth;
	var strDateFieldYear;
	
	var strNaissance;
	
	var idxDay
	var idxMonth
	
	var strDay;
	var strMonth;
	var strYear;
	
	boolReturn = false;
	
	if (tblDateFieldNames == null)
		return(boolReturn);

	for(i = 0; i < tblDateFieldNames.length; i++) 
	{	strDateFieldName = tblDateFieldNames[i];
		strDateFieldCorrectName = strDateFieldName + "_c";
						
		strDateFieldDay = strDateFieldName + "_jour";
		strDateFieldMonth = strDateFieldName + "_mois";
		strDateFieldYear = strDateFieldName + "_annee";
		
		strNaissance = formValue.elements[strDateFieldName].value;
		
		if (strNaissance !== "" && fieldExists(formValue, strDateFieldDay) && fieldExists(formValue, strDateFieldMonth) && fieldExists(formValue, strDateFieldYear))
		{	idxDay = formValue.elements[strDateFieldDay].selectedIndex;
			idxMonth = formValue.elements[strDateFieldMonth].selectedIndex;
			
			strDay = formValue.elements[strDateFieldDay].options[idxDay].text;
			strMonth = formValue.elements[strDateFieldMonth].options[idxMonth].text;
			strYear = formValue.elements[strDateFieldYear].value;
			
			if (!isDateValid (strDay, strMonth, strYear))
			{	if (fieldExists(formValue, strDateFieldCorrectName))
				{	formValue.elements[strDateFieldCorrectName].value = strErrMsg
				};
				boolReturn = true;
			}
		}
	}
return (boolReturn)				
}

//--------------------------------------------------------------------------------------------------------------