/*==================================================

FUNZIONE: formValidate()

DESCRIZIONE:
Convalida i campi di una form sfruttando la funzione fieldValidate().
Nel caso in cui sia specificato il secondo parametro, viene valutata
l'espressione dopo aver validato tutti i campi della form

INPUT:
form = 	l'oggetto che rappresenta la form corrente
func = 	espressione di tipo stringa che rappresenta l'eventuale 
	espressione aggiuntiva da valutare al termine della validazione;
	questo parametro è opzionale
	
OUTPUT:
La funzione restituisce un valore booleano; è responsabilità del programmatore
fare in modo che l'eventuale espressione aggiuntiva sia di tipo booleano

==================================================*/

function formValidate(form, func) {
//return true	//DEBUGGER
var i
var fields = form.elements
var l = fields.length
var valid = false

for (i = 0; i < l; i++) {
	valid = fieldValidate(fields[i])
	if (!valid) {
		return false
	}
}

if (func != null) {
	return eval(func)
} else {
	return true
}
}



/*==================================================

FUNZIONE: fieldValidate()

DESCRIZIONE:
Convalida un campo di una form in base alla presenza dei seguenti attributi
pseudo-HTML:

	ddv-maxlength		Indica il numero massimo di caratteri consentito
	ddv-minlength		Indica il minimo numero di caratteri previsto
	ddv-required		Indica se un campo è obbligatorio (true) o meno (false)
	ddv-required-group	Indica un gruppo di elementi all'interno del quale almeno un elemento è obbligatorio
	ddv-type		Indica il tipo di dato previsto per il campo (numeric, date)
	ddv-regexp		Indica l'espressione regolare in base a cui il campo si considera valido

	ddv-dateformat	Indica il formato della data da considerare valido (en/it - valore predefinito = en)
			L'attributo è preso in considerazione soltanto in combinazione con ddv-type="date"

Nel caso in cui sia specificato il secondo parametro, viene valutata
l'espressione dopo aver validato il campo

INPUT:
field =	l'oggetto che rappresenta il campo da validare
func = 	espressione di tipo stringa che rappresenta l'eventuale 
	espressione aggiuntiva da valutare al termine della validazione;
	questo parametro è opzionale
	
OUTPUT:
La funzione restituisce un valore booleano; è responsabilità dell programmatore
fare in modo che l'eventuale espressione aggiuntiva sia di tipo booleano

==================================================*/

function fieldValidate(field, func) {

/*** Fax AdM: personalizzazione in data 03.12.2009 ***/
if (field.attributes["default-value"] != null) {
	if (field.value == field.attributes["default-value"].value) {
		field.value = "";
	}
}

//ddv-maxlength
if (field.attributes["ddv-maxlength"] != null) {
	if (field.value.length > field.attributes["ddv-maxlength"].value) {
		alert("Le dimensioni del campo \'" + field.attributes["ddv-name"].value + "\' non possono superare " + field.attributes["ddv-maxlength"].value + " caratteri!")
		field.focus()
		return false
	}
}

//ddv-minlength
if (field.attributes["ddv-minlength"] != null) {
	if ((field.value.length < field.attributes["ddv-minlength"].value) && (field.value.length != 0)) {
		alert("Le dimensioni del campo \'" + field.attributes["ddv-name"].value + "\' devono essere di almeno " + field.attributes["ddv-minlength"].value + " caratteri!")
		field.focus()
		return false
	}
}

//ddv-required
if ((field.attributes["ddv-required"] != null) && (field.disabled == false)) {
	//if ((field.attributes["ddv-required"].value.toLowerCase() == "true") && (((field.type == "text") && (isBlank(field.value))) || ((field.type.substring(0,6) == "select") && (field.selectedIndex == 0)))) {
	if (field.attributes["ddv-required"].value.toLowerCase() == "true") {
		if ((field.type == "text" || field.type == "password" || field.type == "textarea") && (isBlank(field.value)))  {
			alert("Inserire un valore nel campo obbligatorio \'" + field.attributes["ddv-name"].value + "\'")
			field.focus()
			return false
		}
		//if ((field.type.substring(0,6) == "select") && (field.selectedIndex == 0)) 	//modificato da Fax AdM per VIRIDIA
		//if ((field.type.substring(0,6) == "select") && (field.selectedIndex == -1)) {
		if ((field.type.substring(0,6) == "select") && (isBlank(field.value))) {
			alert("Selezionare un elemento dall'elenco \'" + field.attributes["ddv-name"].value + "\'")
			field.focus()
			return false
		}
	}
}

//ddv-type
if ((field.attributes["ddv-type"] != null) && (! isBlank(field.value))){
	//Numeric data type validation
	if ((field.attributes["ddv-type"].value.toLowerCase() == "numeric") && isNaN(field.value.replace(".", "").replace(",", "."))) {
		alert("Il campo \'" + field.attributes["ddv-name"].value + "\' prevede un valore numerico!")
		field.focus()
		return false
	}

	//Date data type validation
	if (field.attributes["ddv-type"].value.toLowerCase() == "date") {
		var DateFormat = "en"
		
		if (field.attributes["ddv-dateformat"] != null) {
			DateFormat = field.attributes["ddv-dateformat"].value.toLowerCase()
		}
		
		if (!verifyDateFormat(field.value, DateFormat)) {
			alert("Il campo \'" + field.attributes["ddv-name"].value + "\' prevede un valore di tipo data!")
			field.focus()
			return false
		}
	}

	//Controllo formale. Per le aziende il Codice Fiscale può essere sia di 11 caratteri numerici (partita iva), sia di 16 caratteri alfanumerici (codice fiscale)
	if (field.attributes["ddv-type"].value.toLowerCase() == "partita_fiscale") {
		return_value = true
		/* controllo lunghezza */
		if (field.value.length == 16) {
			field.attributes["ddv-type"].value = "codice_fiscale";
		} else if (field.value.length == 11) {
			field.attributes["ddv-type"].value = "partita_iva";
		} else {
			alert("Il valore inserito nel campo \'" + field.attributes["ddv-name"].value + "\' è errato!")
			field.focus()
			return false
		}
	}

	//Controllo formale del codice fiscale
	if (field.attributes["ddv-type"].value.toLowerCase() == "codice_fiscale") {
		return_value = true
		/* controllo lunghezza */
		if (field.value.length != 16)  return_value = false
		field.value = field.value.toUpperCase()
		/* controllo formale */
		var re = new RegExp("^[A-Z]{6}[0-9]{2}[ABCDEHLMPRST]{1}[0-9]{2}[A-Z]{1}[0-9]{3}[A-Z]{1}$")
		if (field.value.match(re) == null)  return_value = false
		/* controllo carattere di controllo */
		strCodFis = field.value
		ctrlChar = field.value.charAt(15)
		var somma = 0
		for (i=0; i<15; i++) {
			if (((i+1) % 2) != 0) {		//caratteri dispari
				switch (strCodFis.charAt(i)) 
				{
				case '0':
				case 'A':{ somma += 1;  break; }
				case '1':
				case 'B':{ somma += 0;  break; }
				case '2':
				case 'C':{ somma += 5;  break; }
				case '3':
				case 'D':{ somma += 7;  break; }
				case '4':
				case 'E':{ somma += 9;  break; }
				case '5':
				case 'F':{ somma += 13; break; }
				case '6':
				case 'G':{ somma += 15; break; }
				case '7':
				case 'H':{ somma += 17; break; }
				case '8':
				case 'I':{ somma += 19; break; }
				case '9':
				case 'J':{ somma += 21; break; }
				case 'K':{ somma += 2;  break; }
				case 'L':{ somma += 4;  break; }
				case 'M':{ somma += 18; break; }
				case 'N':{ somma += 20; break; }
				case 'O':{ somma += 11; break; }
				case 'P':{ somma += 3;  break; }
				case 'Q':{ somma += 6;  break; }
				case 'R':{ somma += 8;  break; }
				case 'S':{ somma += 12; break; }
				case 'T':{ somma += 14; break; }
				case 'U':{ somma += 16; break; }
				case 'V':{ somma += 10; break; }
				case 'W':{ somma += 22; break; }
				case 'X':{ somma += 25; break; }
				case 'Y':{ somma += 24; break; }
				case 'Z':{ somma += 23; break; }
				}
			} else {	//caratteri pari
				switch (strCodFis.charAt(i)) {
				case '0':
				case 'A':{ somma += 0;  break; }
				case '1':
				case 'B':{ somma += 1;  break; }
				case '2':
				case 'C':{ somma += 2;  break; }
				case '3':
				case 'D':{ somma += 3;  break; }
				case '4':
				case 'E':{ somma += 4;  break; }
				case '5':
				case 'F':{ somma += 5;  break; }
				case '6':
				case 'G':{ somma += 6;  break; }
				case '7':
				case 'H':{ somma += 7;  break; }
				case '8':
				case 'I':{ somma += 8;  break; }
				case '9':
				case 'J':{ somma += 9;  break; }
				case 'K':{ somma += 10; break; }
				case 'L':{ somma += 11; break; }
				case 'M':{ somma += 12; break; }
				case 'N':{ somma += 13; break; }
				case 'O':{ somma += 14; break; }
				case 'P':{ somma += 15; break; }
				case 'Q':{ somma += 16; break; }
				case 'R':{ somma += 17; break; }
				case 'S':{ somma += 18; break; }
				case 'T':{ somma += 19; break; }
				case 'U':{ somma += 20; break; }
				case 'V':{ somma += 21; break; }
				case 'W':{ somma += 22; break; }
				case 'X':{ somma += 23; break; }
				case 'Y':{ somma += 24; break; }
				case 'Z':{ somma += 25; break; }
				}
			}
		}
		somma %= 26;
		switch (somma) {
		case 0:  {chrcontrollo='A'; break;}
		case 1:  {chrcontrollo='B'; break;}
		case 2:  {chrcontrollo='C'; break;}
		case 3:  {chrcontrollo='D'; break;}
		case 4:  {chrcontrollo='E'; break;}
		case 5:  {chrcontrollo='F'; break;}
		case 6:  {chrcontrollo='G'; break;}
		case 7:  {chrcontrollo='H'; break;}
		case 8:  {chrcontrollo='I'; break;}
		case 9:  {chrcontrollo='J'; break;}
		case 10: {chrcontrollo='K'; break;}
		case 11: {chrcontrollo='L'; break;}
		case 12: {chrcontrollo='M'; break;}
		case 13: {chrcontrollo='N'; break;}
		case 14: {chrcontrollo='O'; break;}
		case 15: {chrcontrollo='P'; break;}
		case 16: {chrcontrollo='Q'; break;}
		case 17: {chrcontrollo='R'; break;}
		case 18: {chrcontrollo='S'; break;}
		case 19: {chrcontrollo='T'; break;}
		case 20: {chrcontrollo='U'; break;}
		case 21: {chrcontrollo='V'; break;}
		case 22: {chrcontrollo='W'; break;}
		case 23: {chrcontrollo='X'; break;}
		case 24: {chrcontrollo='Y'; break;}
		case 25: {chrcontrollo='Z'; break;}
		}
		if (ctrlChar != chrcontrollo)  return_value = false
		/*-----------------------------------------*/

		if (!return_value) {
			alert("Il valore inserito nel campo \'" + field.attributes["ddv-name"].value + "\' è errato!")
			field.focus()
			return false
		}
	}

	//Controllo formale della partita iva
	if (field.attributes["ddv-type"].value.toLowerCase() == "partita_iva") {
		return_value = true
		/* controllo lunghezza */
		if (field.value.length != 11)  return_value = false
		field.value = field.value.toUpperCase()
		/* controllo formale */
		var re = new RegExp("^[0-9]{11}$")
		if (field.value.match(re) == null)  return_value = false
		/* controllo carattere di controllo */
		strPI = field.value
		ctrlChar = strPI.charAt(10)
		var char_ctrl = 0
		for (i=0; i<10; i++) {
			char_corrente = strPI.charAt(i)
			if (((i+1) % 2) == 0) {		//caratteri pari
				char_corrente = char_corrente * 2 / 10 + (char_corrente * 2) % 10
			}
			char_ctrl = parseInt(char_ctrl) + parseInt(char_corrente)
		}
		char_ctrl = char_ctrl % 10
		if (char_ctrl != 0) {
			char_ctrl = 10 - char_ctrl
		}
		if (ctrlChar != char_ctrl)  return_value = false
		/*-----------------------------------------*/
		if (!return_value) {
			alert("Il valore inserito nel campo \'" + field.attributes["ddv-name"].value + "\' è errato!")
			field.focus()
			return false
		}
	}
}

//ddv-regexp
if ((field.attributes["ddv-regexp"] != null) && (! isBlank(field.attributes["ddv-regexp"].value))){
	if (!(isBlank(field.value))) {
		var re = new RegExp("^" + field.attributes["ddv-regexp"].value + "$")

		if (field.value.match(re) == null) {
			alert("Il valore inserito nel campo \'" + field.attributes["ddv-name"].value + "\' non rispetta il formato previsto!")
			field.focus()
			return false
		}
	}
}

//ddv-required-group
if (field.attributes["ddv-required-group"] != null) {
	var group = field.attributes["ddv-required-group"].value
	var fields = field.form.elements
	var l = fields.length
	var valid = false
	var fieldList = ""
	var controlType
	var i

	for (i = 0; i < l; i++) {
		if (fields[i].attributes["ddv-required-group"] != null) {
			if (fields[i].attributes["ddv-required-group"].value == group) {
				controlType = fields[i].type
				valid = (valid || ((controlType == "text") && (!(isBlank(fields[i].value)))) || (((controlType == "radio") || (controlType == "checkbox")) && (fields[i].checked)) || ((controlType.substring(0,6) == "select") && (!(isBlank(fields[i].value)))))
				if (valid) {
					break
				} else {
					if (fields[i].name != "") {
						fieldList = fieldList + fields[i].name + ", "
					} else {
						fieldList = fieldList + fields[i].id + ", "
					}
				}
			}
		}
	}
	if(!valid){
		fieldList = fieldList.substring(0, fieldList.length -2)
		if (field.attributes["ddv-campi-misti"]) {
			alert("E' necessario inserire un valore in almeno uno dei campi!")
		} else {
			if (controlType == "text") {
				//alert("E' necessario inserire un valore in almeno uno dei seguenti campi: " + fieldList + "!")
				alert("E' necessario inserire un valore in almeno uno dei campi!")
			}
			if ((controlType == "radio")||(controlType.substring(0,6) == "select")) {
				alert("E' necessario selezionare un valore tra quelli proposti per il campo " + field.name + "!")
			}
			if (controlType == "checkbox") {
				if (field.attributes["ddv-name"]) {
					if (field.attributes["ddv-name"].value == "selezione_campi")  alert("E' necessario selezionare almeno un campo")	//caso specifico per il db-management
					if (field.attributes["ddv-name"].value != "selezione_campi")  alert("E' necessario selezionare almeno un valore alla voce \'" + field.attributes["ddv-name"].value + "\'")
				} else {
					alert("E' necessario selezionare almeno un valore tra quelli proposti!")
				}
			}
		}
		field.focus()
		return false	
	}
}


if (func != null) {
	return eval(func)
} else {
	return true
}
}




/*==================================================

FUNZIONE: verifyDateFormat()

DESCRIZIONE:
Verifica la validità di una data in base al formato specificato.

INPUT:
DateString =	stringa che rappresenta la data da verificare
Format = 	stringa che rappresenta il formato della data in base al quale verificarla;
		sono previsti due formati:
			en	formato inglese (mm/gg/aaaa)
			it	formato italiano (gg/mm/aaaa)

OUTPUT:
La funzione restituisce true se la data è valida; false altrimenti.

==================================================*/

function verifyDateFormat(DateString, DateFormat) {
var match
var tmpDate
var validFormat = false

try {
	match = DateString.match(/^(\d?\d)\D(\d?\d)\D(\d{4}|\d{2})$/)

	if (match != null) {
		if (DateFormat == "en") {
			tmpDate = new Date(match[3], match[1] - 1, match[2])
			validFormat = ((tmpDate.getMonth()==match[1]-1) && (tmpDate.getDate()==match[2]))
		} else {
			tmpDate = new Date(match[3], match[2] - 1, match[1])
			validFormat = ((tmpDate.getMonth()==match[2]-1) && (tmpDate.getDate()==match[1]))
		}
	}
}
catch (e) {
	alert(e.message)
}
finally {
	return validFormat
}
}

/*==================================================

FUNZIONE: setConstraint()

DESCRIZIONE:
Imposta dinamicamente un attributo di validazione.

INPUT:
element =	stringa che indica l'ID dell'elemento
		a cui applicare il vincolo di validazione
		
attribute = 	stringa che indica il nome dell'attributo pseudo-HTML
		da impostare
		
value = 	stringa che indica il valore da assegnare all'attributo
		pseudo-HTML specificato nel parametro attribute

==================================================*/

function setConstraint(element, attribute, value) {
var elem;
var attr;

elem = document.getElementById(element);

if (elem != null) {
	attr = document.createAttribute(attribute);
	attr.value = value;
	elem.setAttributeNode(attr)
}
}



function isBlank( cArg )
{
while ( cArg.length > 0 && cArg.charAt( cArg.length - 1 ) == " " ) {
	cArg = cArg.substring( 0, cArg.length - 1 );
	}
return cArg == "";
}