////////////////////////////////////////////////////////////////////////////////////
///                               Funções JavaScript 	                         ///
///                           Validações de Formulários 	                 ///
///                                   Megaloto                                   ///
////////////////////////////////////////////////////////////////////////////////////

// ---------------------------------------------------------------------------------
// Nome da Função      : Máscarar Data
// Analista            : Alessandro Precioso
// Data                : 03-05-2004
// Utilidade           : Função para mascarar a data
// Sintaxe             : f_MascaraData(Nome do Form.Nome do Campo);
// Exemplo 	       : Esta função deverá ser usada para mascarar data: 15012004 ficar 15/01/2004
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 


function f_MascaraData(cValor){
				      var mydata = '';
				      mydata = mydata + cValor.value;
				      if (mydata.length == 2){
				  mydata = mydata + '/';
				  cValor.value = mydata;
				      }
				      if (mydata.length == 5){
				  mydata = mydata + '/';
				  cValor.value = mydata;
				      }
		  }
// ---------------------------------------------------------------------------------
// Nome da Função      : Desabilita Button
// Analista            : Alessandro Precioso
// Data                : 29-09-2003
// Utilidade           : Função para desabilitar botao
// Sintaxe             : f_DesButton(Nome do Form.Nome do Campo);
// Exemplo 	       : Esta função deverá ser usada para desabilitar botões e com
//			 isso impedir o reenvio de alguma informação
//                       return f_DesButton(form1.fcomprar);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_DesButton(cValor)
{
	cValor.disabled=true;
	return true;
}


// ---------------------------------------------------------------------------------
// Nome da Função      : Habilita Button
// Analista            : Alessandro Precioso
// Data                : 07-09-2003
// Utilidade           : Função para habilitar botao
// Sintaxe             : f_HabButton(Nome do Form.Nome do Campo);
// Exemplo 	       : Esta função deverá ser usada para habilitar botões e com
//			 isso permitir o envio de alguma informação
//                       return f_HabButton(form1.fapostar);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_HabButton(cValor)
{
	cValor.disabled=false;
	return true;
}

// ---------------------------------------------------------------------------------
// Nome da Função      : Validação CheckBox
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função para validar checkboxs nulos
// Sintaxe             : f_ValidarCheckBox(Nome do Form,Nome do Campo,Qtd Indexação);
// Exemplo 	       : Esta função deverá ser usada no final do formulário, 
//                       no momento da validação do formulário
//                       return f_ValidarCheckBox(form1,"fOpcao",3);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarCheckBox(cForm,cValor,nQtd)
{
	var cEnc = false;
	for (var x=1;x<nQtd;x++)
	{
		cOpcao = cValor+x;
		if (cForm.elements[cOpcao].checked)
		{
			cEnc = true;
		}
	}
	if (cEnc == false)
	{
		alert("Por favor, preencha o campo obrigatório");
		return false;
	}
	else
	{
		return true;
	}
}


// ---------------------------------------------------------------------------------
// Nome da Função      : Validação Radio Button
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função para validar radio buttons nulos
// Sintaxe             : f_ValidarRadio(Nome do Form.Nome do Campo);
// Exemplo 	       : Esta função deverá ser usada no final do formulário, 
//                       no momento da validação do formulário
//                       return f_ValidarRadio(form1.fRadio);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarRadio(cValor)
{
    cOk  = false;
    nQtd = cValor.length;
    for (i=0;i<nQtd;i++)
    {
    	if (cValor[i].checked)
    	{
        	cOk = true;
        	break;
        }
    }
    if (cOk)
    {
    	return true;
    }
    else
    {
	alert("Por favor, preencha o campo obrigatório");
    }
}


// ---------------------------------------------------------------------------------
// Nome da Função      : Validação de Hora
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função que verifica sea hora digitada é válida
// Sintaxe             : f_ValidarHora(Nome do Form, Hora);
// Exemplo 	       : Esta função deverá ser usada no final do formulário, 
//                       no momento da validação do formulário
//                       return f_ValidarHora(form1,form1.fHora);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarHora( cCampo )
{
    var cHr, cMin;
    
    cHr  = cCampo.value.substr( 0,2 );
    cMin = cCampo.value.substr( 3,2 );
    
    // Verifica se a hora foi digitada corretamente
    if ( ( cCampo.value.substr(2,1) == ':' ) &&
         ( ( parseInt( cHr  ) >= 0 ) && ( parseInt( cHr  ) <= 23 ) ) &&
         ( ( parseInt( cMin ) >= 0 ) && ( parseInt( cMin ) <= 59 ) ) )
    {
      return ( true );
    }
    else
    {
      alert( 'Favor fornecer a hora em um formato válido (HH:MM).' );
      cCampo.focus();
      return false;
    }
}


// ---------------------------------------------------------------------------------
// Nome da Função      : Validação de Período
// Analista            : Alessandro Precioso
// Data                : 28-06-2002
// Utilidade           : Função que verifica a validade de um período
// Sintaxe             : f_ValidarPeriodo(Nome do Form, Data inicial, Data Final);
// Exemplo 	       : Esta função deverá ser usada no final do formulário, 
//                       no momento da validação do formulário
//                       return f_ValidarPeriodo(form1,form1.DtIni, form1.DtFim);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarPeriodo( cForm, cDtIni,cDtFim )
{
    var cDtIniAux, cDtFimAux;
    
    cDtIniAux = cDtIni.value.substr( 6,4 ) + cDtIni.value.substr( 3,2 ) + cDtIni.value.substr( 0,2 );
    cDtFimAux = cDtFim.value.substr( 6,4 ) + cDtFim.value.substr( 3,2 ) + cDtFim.value.substr( 0,2 );
    
    if ( cDtIniAux > cDtFimAux )
    {
      alert( 'A data inicial não pode ser posterior à data final do período' );	    
      return false;
    }
    else
    { 
      // Verifica se a quantidade de dias do período é maior que o limite
      // Em implantação
      
    
      return true;
    }
}


// ---------------------------------------------------------------------------------
// Nome da Função      : Edição do Campo
// Analista            : Alessandro Precioso
// Data                : 28-06-2002
// Utilidade           : Função que verifica se o campo em que a função está sendo chamada
//   	 	         poderá ser editado.
// Sintaxe             : f_EditaCampo(Nome do Form, Nome do Campo);
// Exemplo 	       : <input type=hidden name=feditadata>
//                       <input type=text name=fdata onFocus="return f_EditaCampo(form1,this);">
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_EditaCampo( cForm,cCampo )
{
    nValor = cCampo.name.substr(0,1) + 'edita' + cCampo.name.substr(1)
    if ( cForm.elements[nValor].value == 'N' )
    {
    	cCampo.blur();
    }
    return true;
}

// ---------------------------------------------------------------------------------
// Nome da Função      : Validação de Tamanho
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função que verifica a quantidade de caracteres digitados em um
//			 determinando objeto do form.
// Sintaxe             : f_ValidarTamanho(Nome do Campo, Maximo de Caracteres)
// Exemplo 	       : f_ValidarTamanho(form1.fcObs,120);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarTamanho(cCampo,nTamanho)
{
	if ((cCampo.value.length > nTamanho) && (cCampo.value.replace(' ','') != ""))
	{
		alert('O campo suporta apenas ' + nTamanho + ' caracteres!');
		return false;
	}
	else
	{
		return true;
	}
}

// ---------------------------------------------------------------------------------
// Nome da Função      : Validação de Data
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : 1 - Função que verifica se a data é valida.
//			 2 - Verifica se a data mais hoje é maior que a data informada
//			 3 - Verifica se a data atual é maior que a data informada
//			 4 - Verifica se a data mais hoje é menor que a data informada
//			 5 - Verifica se a data atual é menor que a data informada
// Sintaxe             : f_ValidarData(Campo do Form);
// Exemplo 	       : f_ValidarData(fcData); --> 1
//			 f_ValidarData(fcData,'HF'); --> 2
//			 f_ValidarData(fcData,'F'); --> 3
//			 f_ValidarData(fcData,'AH'); --> 4 não permite data > q atual
//			 f_ValidarData(fcData,'A'); --> 5
// Data Ult. Alteração : 
// ---------------------------------------------------------------------------------- 

function f_ValidarData( cCampo, cTipo )
{
	var Data = new Date();
	var dHoje = new Date(Data.getYear(),Data.getMonth(),Data.getDate(),0,0,0)
	var nMes, cMes;
	var dDataFornecida;
	var str = cCampo.value;
	var cErro = 'Por favor, digite a data corretamente ( Ex. 14/05/2001 )';

	if (str.replace(' ','') != "")
	{
		// Verifica se foram digitados 10 caracteres.
		if (str.length != 10)
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}
		// Verifica se os caracteres são números e barra.
		for (var i = 0; i < str.length; i++)
		{
			var ch = str.substring(i, i + 1);
			if ((ch < "0" || "9" < ch) && ch != "/")
			{
				alert(cErro)
				cCampo.focus();
				return false;
			}
		}

		// Verifica o valor do dia.
		if ( (str.substring(0, 2) < 1) || (str.substring(0, 2) > 31) )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}

		// Verifica o valor do dia no valor do mês.
		// Fevereiro
		if ( (str.substring(3, 5) == 2 ) && (str.substring(0, 2) > 29) )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}
		if ( (str.substring(3, 5) == 2 ) && (str.substring(0, 2) == 29) )
		{
			if (!confirm('\nVocê entrou com 29 de Fevereiro...\n\nVocê tem certeza de que é ano bissexto?'))
			{
				cCampo.focus();
				return false;
			}
		}

		// Abril
		if ( (str.substring(3, 5) == 4 ) && (str.substring(0, 2) > 30) )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}

		// Junho
		if ( (str.substring(3, 5) == 6 ) && (str.substring(0, 2) > 30) )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}

		// Setembro
		if ( (str.substring(3, 5) == 9 ) && (str.substring(0, 2) > 30) )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}

		// Novembro
		if ( (str.substring(3, 5) == 11 ) && (str.substring(0, 2) > 30) )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}

		// Verifica o valor do mês.
		if ( (str.substring(3, 5) < 1) || (str.substring(3, 5) > 12) )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}


		// Verifica posicionamento da barra.
		if ( str.substring(3, 4) == "/" || str.substring(4, 5) == "/" )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}

		if ( str.substring(0, 1) == "/" || str.substring(1, 2) == "/" )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}

		if ( str.substring(6, 9) == "/" || str.substring(7, 10) == "/" )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}

		if ( str.substring(2, 3) != "/" || str.substring(5, 6) != "/" )
		{
			alert(cErro)
			cCampo.focus();
			return false;
		}


		// Verifica se a data é anterior a hoje
		if ( str.substring(3,5) == 1)
		{
			nMes = 12;
		}
		else
		{
			nMes = str.substring(3,5) - 1;
		}

		dDataFornecida = new Date( str.substring(6,10), nMes, str.substring(0,2) );

		if ( toString( dDataFornecida.getMonth() ).lenght  < 2 )
		{
			cMes = "0" + toString( dDataFornecida.getMonth() );
		}
		else
		{
			cMes = toString( dDataFornecida.getMonth() );
		}

		if (cTipo == "F")
		{
			if ( dDataFornecida <=  dHoje )
			{
				alert("\nA Data não pode ser menor que a Data de Hoje!");
				cCampo.focus();
				return false;
			}
		}
		else if (cTipo == "A")
		{
			if ( dDataFornecida >=  dHoje )
			{
				alert("\nA Data não pode ser maior que a Data de Hoje!");
				cCampo.focus();
				return false;
			}
		}
		else if (cTipo == "HF")
		{
			if ( dDataFornecida <  dHoje )
			{
				alert("\nA Data não pode ser menor que a Data de Hoje!");
				cCampo.focus();
				return false;
			}
		}
		else if (cTipo == "AH")
		{
			if ( dDataFornecida >  dHoje )
			{
				alert("\nA Data não pode ser maior que a Data de Hoje!");
				cCampo.focus();
				return false;
			}
		}
	return true;
	}
	else
	{
	 return true;
	}

}


// ---------------------------------------------------------------------------------
// Nome da Função      : Validar apenas caracteres
// Analista            : Alessandro Precioso
// Data                : 28-06-2002
// Utilidade           : Função que verifica se foi informado apenas letras no campo
// Sintaxe             : f_ValidarString(Nome do Campo);
// Exemplo 	       : f_ValidarString(form1,this);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarString(cCampo)
{
	var valid = "àáãâéêõôóabcdefghijklmnopqrstuvwxyz ÀÁÃÂÉÊÕÔÓABCDEFGHIJKLMNOPQRSTUVWXYZ"
	var ok = "yes";
	var temp;
	for (var i=0; i<cCampo.value.length; i++)
	{
		temp = "" + cCampo.value.substring(i, i+1);
		if (valid.indexOf(temp) == "-1") ok = "no";
	}
	if (ok == "no")
	{
		alert("Por favor, digite apenas letras!");
		cCampo.focus();
		return false;
	}
	else
	{
		return true;
	}
}

// ---------------------------------------------------------------------------------
// Nome da Função      : Validação de Número Reais
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função que verifica se o valor do campo informado é um numero real
//			 Ex: 1.25  1,25
// Sintaxe             : f_ValidarNumeroReal(Nome do Campo, cSep);
// Exemplo 	       : f_ValidarNumeroReal(form1,this);
// Data Ult. Alteração : 
// Alterações          : Inclusão do parâmetro cSep, que indica qual separador
//                       deverá ser considerado (vírgula ou ponto ).
// ---------------------------------------------------------------------------------- 


function f_ValidarNumeroReal(nNumero, cSep)
{
	var x=nNumero.value
	var cFiltroVirgula=/(^\d+$)|(^\d+\,\d+$)/
	var cFiltroPonto=/(^\d+$)|(^\d+\.\d+$)/
	var cFiltro
	
	if ( cSep == "," )
	{
	  cFiltro = cFiltroVirgula;
	}
	else
	{
	  cFiltro = cFiltroPonto;
	}
	
	if ((!cFiltro.test(x)) && (nNumero.value.replace(' ','') != ""))
	{
	  if ( cSep == "," )
	  {
	    alert("Por favor, preencha um número válido! ( Somente Algarismos e Vírgula )");
	  }
	  else
	  {
	    alert("Por favor, preencha um número válido! ( Somente Algarismos e Ponto )");
	  }
	  	
	  nNumero.focus();
	  return false;
	}
	else
	{
	  return true;
	}
}

// ---------------------------------------------------------------------------------
// Nome da Função      : Validação de Número Inteiro
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função que verifica se o valor do campo é um Numero Inteiro
//   	 	         Ex. 20
// Sintaxe             : f_ValidarNumeroInteiro(Nome do Campo);
// Exemplo 	       : f_ValidarNumeroInteiro(form1,this);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarNumeroInteiro(nNumero)
{
	var x=nNumero.value
	var cFiltro=/(^\d+$)|(^\d+\\d+$)/
	if ((!cFiltro.test(x)) && (nNumero.value.replace(' ','') != ""))
	{
		alert("Por favor, use somente números!");
		nNumero.focus();
		return false;
	}
	else
	{
		return true;
	}
}

// ---------------------------------------------------------------------------------
// Nome da Função      : Validação de Campo Nulos
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função que verifica se o valor do campo é nulo
// Sintaxe             : f_ValidarCamposNulos(Nome do Campo);
// Exemplo 	       : f_ValidarCamposNulos(form.nome do campo);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarCamposNulos(cCampo)
{
	if (cCampo.value.replace(' ','') == "")
	{
		alert("Por favor, preencha o campo obrigatório");
		cCampo.focus();
		return false;
	}
	else
	{
		return true;
	}
}

// ---------------------------------------------------------------------------------
// Nome da Função      : Validação de E-mail
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função que verifica se o e-mail informada é válido
// Sintaxe             : f_ValidarEmail(Nome do Campo);
// Exemplo 	       : f_ValidarEmail(form1,this);
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarEmail(cEmail)
{
	var str=cEmail.value
	var cFiltro=/^.+@.+\..{1,3}$/
	if ((!cFiltro.test(str)) && (cEmail.value.replace(' ','') != ""))
	{
		alert("Por favor, insira um e-mail válido!")
		cEmail.focus();
		return false;
	}
	else
	{
		return true;
	}
}

// ---------------------------------------------------------------------------------
// Nome da Função      : Validação de N Campos Obrigatórios
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função que verifica se o usuário preencheu pelo menos N campos
//			 em um formulário.
// Sintaxe             : f_ValidarUmCampo(Nome do Form,Qtd de Campo Necessários,Nome dos Campos);
// Exemplo 	       : f_ValidarUmCampo("form1",2,new Array ("campo1","campo2","campo3"));
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarUmCampo(cForm,nQtd,cCampo)
{
	var cErro = 0;
	for (x=0;x<cCampo.length;x++)
	{
		campo = cCampo[x];
		if (top.document.forms[cForm].elements[campo].value.replace(' ','') != "")
		{
			cErro++;
		}
	}
	if (cErro < nQtd)
	{
		alert('Por favor, você precisa preencher pelo menos ' + nQtd + ' dos campos descritos!');
	}
	else
	{
		return true;
	}
}


// ---------------------------------------------------------------------------------
// Nome da Função      : f_ValidarPlaca
// Analista            : Alessandro Precioso
// Data                : 27-06-2002
// Utilidade           : Função que verifica se uma placa de automóvel foi digitada corretamente
// Sintaxe             : f_ValidarString(Nome do Campo, Máscara);
// Exemplo 	       : f_ValidarString(form1.fPlaca, '-');
//                       Observação : se o 2º parâmetro for omitido, significa que a
//                       máscara não faz parte da informação. e não deverá ser validada
// Data Ult. Alteração : 
// Alterações          :
// ---------------------------------------------------------------------------------- 

function f_ValidarPlaca(cCampo, cMascara)
{
	var aLetras  = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	var aNumeros = "0123456789"
	var ok = "yes";
	var temp;
	var cMsgAdic;
	var nPosIniNr;
	
	// Valida a máscara e define a mensagem adequada para ser mostrada em caso de erro
	if ( cMascara == "-" )
	{ cMsgAdic = ',\n separados por traço (-)';
	  if ( cCampo.value.substr(3,1) != '-' ) ok = "no";
	  nPosIniNr = 4;
	}
	else
	{ cMsgAdic = '';
	  nPosIniNr = 3;
	}
	  	
	// valida as letras
	for (var i=0; i<=2; i++)
	{
	  if (aLetras.indexOf(cCampo.value.substr(i,1)) == -1){ ok = "no"};
	}
	if (ok == "no")
	{
	  alert("A placa deve ser informada com 3 letras e 4 números" + cMsgAdic);
	  cCampo.focus();
	  return false;
	}	
	
	// valida os números
	ok = "yes";
	for (var i=nPosIniNr; i<cCampo.length; i++)
	{
	  temp = "" + cCampo.value.substring(i, i+1);
	  if (aNumeros.indexOf(temp) == "-1") ok = "no";
	}
	if (ok == "no")
	{
	  alert("A placa deve ser informada com 3 letras e 4 números" + cMsgAdic);
	  cCampo.focus();
	  return false;
	}		
	else { return true; }
}