/************************************************************************************************
* Autor   : Elpidio N Lima Junior                                                               *
* email   : junior@dev2net.com.br                                                               *
* data    : 27/05/2003 as 23:30                                                                 *
* altera  : 28/05/2003 as 15:58                                                                 *
*===============================================================================================*
*       DESCRIÇÃO               :FUNÇÃO PARA MASCARAR CARACTERS (CEP, TELEFONE, RG, CPF, ETC...)*
*       FUNCTION PRINCIPAL      : mascara(pValor, pMascara)                                     *
*       PARAMETROS              : (pValor, pMascara)                                            *
*                                       pValor = Valor que deseja mascarar                      *
*                                       pMascara = Formato ao qual deseja tornar o pValor       *
*                                       pQtdDigitos = tamanho minimo do campo                   *
*                                       ZE          = Se conterá caracteres a esquerda          *
*                                       ZD          = Se conterá caracteres a direita           *
*       EXEMPLO                 : mascara('25021981', '99/99/9999',8,N,N)                       *
*       RESULTADO               : '25/02/1981'                                                  *
*       EXEMPLO2                : mascara('09780', '99999-999',8,N,S0)                          *
*       RESULTADO               : '09780-000'                                                   *
*                                                                                               *
*       OBS:                                                                                    *
*       No Parametro ZE ou ZD vc pode especificar qual caracter quer colocar para preencher     *
*       o espaço caso os digitos fornecidos pelo usuario seja menos que o da mascara.           *
*       Preencha somente um desses parametros. Se utilizar ZE = 'S' então utilize ZD ='N'       *
*       ou vice-versa.
************************************************************************************************/
function mascara (pValor, pMascara,pQtdDigitos,ZE,ZD){

        /***********************************************************************************************
        *                                                                                              *
        *       pValor          = Valor a ser mascarado                                                *
        *       pMascara        = Mascara fornecida para mascarar o pValor                             *
        *       pQtdDigitos     = Quantidade minima de digitos, caso não                               *
        *                         seje fornecido a quantidade mínima utilizada                         *
        *                         é a do parametro pMascara.length                                     *
        *       ZE = Caracters a esquerda  S[caracter] ou N                                            *
        *       ZD = Caracters a direita  S[caracter] ou N                                             *
        ***********************************************************************************************/


        var vValor   	= extrair_numero(pValor);  // retira somente os numeros do valor passado como parametro
        var novoValor 	=""; 	//Armazena o valor mascarado final
        var pA 			= 0; 	//posicao anterior utilizado para pesquisa do substring  na rotina para substituição e formação da mascara
        var tI			= 1; 	//Variavel de contagem de itens no array : Total de itens
        var vMascara; //utilizada para amazena a qtd de caracters dos valor fornecidos pelo usuário.

        //se não for passado o tamnho minino de caracteres ele assume o tamanho da mascara fornecida
        if (!pQtdDigitos && pQtdDigitos!=0){
                vMascara = extrair_numero(pMascara).length;
        }else{
                vMascara = pQtdDigitos;
        }

        /****************************************************************************************************************
	*   rotina para verificar se existe valor e se existir, valida o tamanho.                                       *
        *   caso o tamanho seje menor ao forcecido verifica se é para acrescentar caracteres a esquerda ou a direita    *
	****************************************************************************************************************/
                //se não for passado nada sai da função sem calcular nada
                if (vValor ==""){
                        return vValor;
                }else{//se a qtd de digito do valor fornecido for menor que a qtd estipulada exibe msg.
                        if(vValor.length < vMascara){

                                //acrescenta caracters a direita ou a esquerda dos numeros
                                var vZE="", vZD="";
                                if(ZD || ZE){ //se for passado algum dos parametros
                                        if (ZE.substring(0,1)=="S" || ZD.substring(0,1)=="S" ){
                                                //verifica qual foi utilizado (esquerdo ou direito)
                                                if(ZE.substring(0,1)=="S"){
                                                        vZE = ZE.substring(1,2);
                                                }else{
                                                        vZD = ZD.substring(1,2);
                                                }

                                                var qtd = vMascara - vValor.length;
                                                for($i=0;$i < qtd;$i++){
                                                        vValor = vZE + vValor + vZD;
                                                }
                                        }
                                }

                                /* se o parametro pQtdDigitos = 0 ele não é para ser validado
                                porque estes campos não precisa de validação de tamanho mínivo.
                                Someten valida se o tamanho for maior que 0 e os parametros ZE e ZD forem iguais a nulo.
                                */
                                if (vMascara>0 && vZE=="" && vZD==""){
                                        alert ("Este campo deve ter no mínimo " + vMascara + " dígitos.");
                                        return ""; //pValor;
                                }
                        }
                }
        /*=========================================================================================================== ==*/


	/****************************************************************************************************************
	*   rotina para criar array e reitirar os caracters de mascara passado por parametro                            *
	****************************************************************************************************************/
		//cria um array atraves da function CriaArrayDados()
		posicao = new CriaArrayDados(2);

		//Cria um array 0 para iniciar a pesquisa no substring 0 ao 0 incluindo ""
		posicao[0]=new CriaArrayDados("0","");

		//Inicia um pesquisa a itens não numéricos
		for (i=0; i < pMascara.length;i++){
			   if(pMascara.substring(i,i+1) != 9 && pMascara.substring(i,i+1) != 0){
					posicao[tI]= new CriaArrayDados(i - (tI-1), pMascara.substring(i,i+1));
					tI++;
				}
		}
		//cria um array após o ultimo registro para incluir "" e carregar o restante dos dados
		posicao[tI]= new CriaArrayDados(i - (tI-1), "");  tI++;
	/*=============================================================================================================*/


	/****************************************************************************************************************
	*  rotina para substituição e formação da mascara			                                        *
	****************************************************************************************************************/
	        for(ii=0;ii <= vValor.length + (tI) ;ii++){
			for(i=0; i < tI;i++){
				if(ii == posicao[i].Campo){

					novoValor += vValor.substring(pA,posicao[i].Campo) + posicao[i].Conteudo ;

					pA = posicao[i].Campo; //Grava como posição anterior a posição atual.

				}
			}
		}
	/*===============================================================================================================*/

		return novoValor;
}

//retorna a data ATual
function dataAtual(){
	var insDate = new Date();
	var dia = insDate.getDate();
	var mes = insDate.getMonth()+1;
	var ano = insDate.getFullYear();
	      
	return  mascara(''+dia+'','99',2,'S0','N') + '/' +
			mascara(''+mes+'','99',2,'S0','N') + '/' +
			mascara(''+ano+'','9999',4,'N','S0');
}

//calcula a diferenca entre datas
function calcular_dias(dataAtual, dataFornecida, idadeLimite){

		//data Atual
		var diaA = dataAtual.substring(0,2);
		var mesA = dataAtual.substring(3,5);
		var anoA = dataAtual.substring(6,10);

		//data 
		var diaF = dataFornecida.substring(0,2);
		var mesF = dataFornecida.substring(3,5);
		var anoF = dataFornecida.substring(6,10);

		//calcula a idade diretamente pelo ano
		var dias = diaA - diaF;

		//verifica a diferença dos meses e dias
		if((mesA < mesF && diaF == diaA) ||
		(mesA == mesF && diaF > diaA) ||
		(anoA == anoF && mesA == mesF && diaA < diaF   || mesA < mesF )){
				vIdade--;
		}
		return vIdade;
}

function calcular_ano(dataAtual, dataFornecida, idadeLimite){

		//data Atual
		var diaA = dataAtual.substring(0,2);
		var mesA = dataAtual.substring(3,5);
		var anoA = dataAtual.substring(6,10);

		//data 
		var diaF = dataFornecida.substring(0,2);
		var mesF = dataFornecida.substring(3,5);
		var anoF = dataFornecida.substring(6,10);

		//calcula a idade diretamente pelo ano
		var vIdade = anoA - anoF;

		//verifica a diferença dos meses e dias
		if((mesA < mesF && diaF == diaA) ||
		(mesA == mesF && diaF > diaA) ||
		(anoA == anoF && mesA == mesF && diaA < diaF   || mesA < mesF )){
				vIdade--;
		}
		return vIdade;
}

/****************************************************
* FUNÇÃO criada em:26/08/2003.                      *
* Retirar espaçoes de uma variavel                  *
* PARAMETROS:                                       *
*       posicao = "P"; retira espaço das pontas     *
*       posicao = "Q"; retira os espaço da variavel *
*       VALOR   = valor a ser formatado             *
****************************************************/
function tira_espacos(valor,posicao){

        var novo_valor="";

        if (posicao == "P"){
                for (i=0;i<valor.length;i++){
                        if (valor.substring(i,i+1)!=" "){
                                novo_valor=valor.substring(i,valor.length);
                                break;
                        }
                }

                for (i=novo_valor.length;i>0;i--){
                        if (novo_valor.substring(i-1,i)!=" "){
                                novo_valor=novo_valor.substring(0,i);
                                break;
                        }
                }
        }else{
                for (i=0;i<valor.length;i++){
                        if (valor.substring(i,i+1)!=" "){
                                novo_valor+=valor.substring(i,i+1);
                        }
                }

        }
        return novo_valor;
}

/***********************************************
* Criar Array : utilizado na funçao mascara    *
***********************************************/
function CriaArrayDados (Campo, Conteudo){
	this.Campo = Campo
	this.Conteudo =Conteudo
}

/***********************************************
* verifica se um variável é numerica           *
***********************************************/
function e_numero(Valor){
   var i;

   for (i = 0; i < Valor.length; i++){
      if (Valor.charAt(i) < "0" || Valor.charAt(i) > "9" ){
         return false;
      }
   }
   return true;
}
/***********************************************
* Extrair somente numeros de uma variavel      *
***********************************************/
function extrair_numero(pValor){
		var valor = "";
		if(pValor.type=="text"){
			valor=pValor.value;
		}else{
			valor=pValor;
		}
        var i, cr, numero
        numero="";
        for (i = 0; i < valor.length; i++) {
                cr = valor.substring(i, i+1);
                if ((cr >= "0" && cr <= "9")) {
                        numero += cr;
                }
        }
        return numero;
		if(pValor.type=="text"){pObject.focus();}
}
/***********************************************
* Extrair somente letras de uma variavel      *
***********************************************/
function extrair_letras(valor){
        var i, cr, letra
        letra="";
        for (i = 0; i < valor.length; i++) {
                cr = valor.substring(i, i+1);
                if (!(cr >= "0" && cr <= "9")) {
                        letra += cr;
                }
        }
        return letra;
}

/*********************************************************************
* Arredonda rg. acrescenta 0.. a esquerda se for menor que 8 digitos *
*********************************************************************/
function arredonda_rg (conteudo,tipo){

         /************************************
         *       Parametros                  *
         *************************************
         * tipo: Pode ser                    *
         *       AZ = Acrescentar Zeros      *
         *       TD = Tirar digito           *
         * conteudo: Valor a ser arredondado *
         ************************************/

        if(tipo=='AZ'){
                var nr="";
                var numero_rg= extrair_numero(conteudo);

                if (numero_rg.length==0){return "";}

                nr="";
                if(numero_rg.length < 8){
                        for(i = 0; i < (8-numero_rg.length); i++){
                                nr += "0";
                        }
                        conteudo = nr + numero_rg ;
                        return  conteudo;
                }else{
                        return conteudo;
                }
        }else{
                if(conteudo.length==11){
                        return conteudo.substring(0,10);
                }else{
                        return conteudo;
                }
        }
}

/******************************************************************
*        FUNÇÃO PARA ARREDONDAMENTO DE HORAS                      *
*        PARAMENTROS:                                             *
*        conteudo: valor a ser arredondado                        *
*        tipo    : tipo hh:mm ou hh:mm                            *
*        valida_hora: valida a quatidade máxima de hora.          *
*        valida_minuto: valida a quatidade máxima de minutos.     *
*                                                                 *
******************************************************************/
function arredonda_hora (conteudo,tipo,valida_hora,valida_minuto){

        //utiliza somente os numeros da variavel passada.

        var nValida_hora = extrair_numero(valida_hora);
        var nValida_minuto = extrair_numero(valida_minuto);

        conteudo = extrair_numero(conteudo).substring(0,5);

        var nValor = "";
        var nIndex = 0;
        
        if(tipo=="hhh:mm"){
                /**********************************************
                *       Arredonda a Hora no Formato HHH:MM    *
                **********************************************/

                nIndex = 3;

                if (conteudo.length ==1){
                        nValor = conteudo = "0000" + conteudo;
                }else if (conteudo.length ==2){
                        nValor = conteudo = "000" + conteudo;
                }else if (conteudo.length ==3){
                        nValor = conteudo = "00" + conteudo;
                }else if (conteudo.length ==4){
                        nValor = conteudo = "0" + conteudo;
                }else if (conteudo.length >=5){
                        nValor = conteudo;
                }
        }else{
                /**********************************************
                *       Arredonda a Hora no Formato HH:MM     *
                **********************************************/

                nIndex = 2;
                if (conteudo.length ==1){
                        nValor = conteudo = "000" + conteudo;
                }else if (conteudo.length ==2){
                        nValor = conteudo = "00" + conteudo;
                }else if (conteudo.length ==3){
                        nValor = conteudo = "0" + conteudo;
                }else if (conteudo.length >=4){
                        nValor = conteudo;
                }

        }
        if(!valida_hora){valida_hora="";}
        if(!valida_minuto){valida_minuto="";}

        if (valida_hora.substring(0,1)=="S"){
                if (nValor.substring(0,nIndex) > nValida_hora){
                        alert("As horas não podem ultrapassar "+ nValida_hora +"!");
                        nValor = nValida_hora + nValor.substring(nIndex,6);
                }
        }

        if (valida_minuto.substring(0,1)=="S"){
               if (nValor.substring(nIndex,6) > 59){
                        alert("Os minutos não podem ultrapassar " + nValida_minuto+"!");
                        nValor = nValor.substring(0,nIndex) + nValida_minuto;
                }
        }
        if(nIndex==2){
              return mascara(nValor,'99:99',4,'N','N');
        }else if(nIndex==3){
              return mascara(nValor,'999:99',5,'N','N');
        }

}


/********************************************************************************
* MASCARA moeda exemplo:                                                        *
*               valor = 123456789                                               *
*               retorna 1.234.567,89                                            *
*               ou      1.234.567.89,00 dependendo do pDecimaAutomatico         *
* ADAPTADO POR ELpidio N Lima Junior                                            *
* email   : elpidio.junior@sstinfodesign.com.br                                 *
* pValor        = valor a ser mascarado incluindo decimal                       *
* pTamanho      = qtd de digitos                                                *
* pPodeNegativo = se pode ser negativo ou não  (S/N)                            *
* pDecimaAutomatico = Define se o decimal é Automatico ou não                   *
*                      Atumatico é pegar as duas ultimas poscoes como decimal   *
*                      true ou false                                            *
*********************************************************************************/
function mascara_moeda(pValor, pTamanho, podeNegativo, pDecimaAutomatico){
	  var msg= "";
        if (pValor == ""){
                return pValor;
        }

        /*valida se o numero é negativo e retira o sinal para realizar o calculo*/
        if (podeNegativo=="S"){
                var vIndicardorNegativo = pValor.substring(0,1);
                if (vIndicardorNegativo=="-"){
                        pValor = pValor.substring(1,pValor.length);
                }
        }
        /*FIM valida se o numero é negativo e retira o sinal para realizar o calculo*/

        var sExpressao	  = pValor;
        var sExpressaoAux = pValor;
	  if (pDecimaAutomatico == true){
		sExpressaoAux = extrair_numero(pValor);
		if(sExpressaoAux.length>=2){
			sExpressaoAux = sExpressaoAux.substring(0,sExpressaoAux.length-2)+ "," + sExpressaoAux.substring(sExpressaoAux.length-2,sExpressaoAux.length);
		}
	  }

        // Retiro pontos e virgulas
        sExpressao = iReplace(sExpressao, ".", "");	
        sExpressao = iReplace(sExpressao, ",", "");

        // Verifico se o que sobra é número
        if(!e_numero(sExpressao)){
                if(podeNegativo!="S"){msg=" ou valores maiores que zero"}
                window.alert('Insira somente valores numéricos' + msg + '!');
                return "0,00";
        }

        //verifica se o numero inicia com zero
        //caso inicie ele tira
        var i, vPosicao
        var vFlagPrimeiroZero = false;
        var sExpressaoTemp = sExpressao;

        for (i=0;i<sExpressao.length;i++){
                if(sExpressao.substring(i,i+1) > 0 ){
                        break;
                }
        }

	  
        if (i>0 && pValor.substring(0,1)!=","){
                sExpressaoTemp = sExpressao.substring(i,sExpressao.length);
                sExpressao=sExpressaoTemp;
                sExpressaoAux=sExpressao;
        }
        //fim verificacao se inicio com zero


        //coloca a virgula se o numero for preenchido completamente e não completa com zeros a direita
        if(sExpressao.length >= pTamanho){
                sExpressao = sExpressao.substring(0,pTamanho-2) + "," + sExpressao.substring(pTamanho-2,9);
                sExpressaoAux = sExpressao;
        }
        //fim coloca a virgula se o numero for preenchido completamente e não completa com zeros a direita

        //coloca a virgula se o numero for preenchido faltando o ultimo numero e completa com 1 zero a direita
        if (sExpressao.length == pTamanho-1){
                sExpressao = sExpressao.substring(0,pTamanho-2) + "," + sExpressao.substring(pTamanho-2,9) + "0";
                sExpressaoAux = sExpressao;
        }
        //fim coloca a virgula se o numero for preenchido faltando o ultimo numero e completa com 1 zero a direita

        // Se houver ultima virgula, monto os 2 decimais após a mesma
        var sDecimais;
        nUltimaVirgula = sExpressaoAux.lastIndexOf(",");

        if(nUltimaVirgula > -1){
                sDecimais = sExpressaoAux.substr(nUltimaVirgula+1,2)

                if(sDecimais.length == 0){
                        sDecimais = sDecimais + "00";
                }

                if(sDecimais.length == 1){
                        sDecimais = sDecimais + "0";
                }

        }else{
                sDecimais = "00";
        }

        // Limpo a parte de números inteiros
        if(nUltimaVirgula > -1){
                sInteiros = sExpressaoAux.substr(0,nUltimaVirgula);
        }else{
                sInteiros = sExpressaoAux;
        }
        sInteiros = iReplace(sInteiros , ".", "");
        sInteiros = iReplace(sInteiros , ",", "");

        if(sInteiros != ""){
                nInt = sInteiros.length - 1;
                var aux = "";
                var nCont = 0;
                for(nInt; nInt > -1; nInt--){
                        nCont = nCont + 1;
                        if(nCont == 4){
                                bPoePonto = true;
                                nCont = 1;
                        }else{
                                bPoePonto = false;
                        }

                        if(bPoePonto == true){
                                aux = sInteiros.charAt(nInt) + "." + aux;
                        }else{
                                aux = sInteiros.charAt(nInt) + aux;
                        }
                }
                sInteiros = aux;
        }else{
                sInteiros = "0";
        }

        /*valida se o numero é negativo e recoloca o sinal */
        if (vIndicardorNegativo=="-"){
                return  vIndicardorNegativo + "" + sInteiros + "," + sDecimais;
        }else{
                return  sInteiros + "," + sDecimais;
        }

}

//preenche com o valor pPreencher se pValor for = pValor1
function preenche_valor (pValor, pValor1, pPreencher){
        if(pValor == pValor1){
                return pPreencher;
        }else{
                return pValor;
        }
}
/*********************************************************
* valida a data levando em consideração os anos bisestos *
*********************************************************/
function e_data(pcampo){

        var err = 0
        var psj = 0;

        var a = pcampo;

        if (a.length != 10) return false;

        b = a.substring(0, 2);  // dia
        c = a.substring(2, 3);  // "/"
        d = a.substring(3, 5);  // mes
        e = a.substring(5, 6);  // "/"
        f = a.substring(6, 10); // ano

        //checa erro basico
        if (b<1 || b>31)      err = 1;
        if (c != "/")         err = 1;
        if (d<1 || d>12)      err = 1;
        if (e != "/")         err = 1;
        if (f<1900 || f>2500) err = 1;
        if (!e_numero(b))     err = 1;
        if (!e_numero(d))     err = 1;
        if (!e_numero(f))     err = 1;

        if (err != 1) {
                //verificacao avancada de erros
                // meses com 30 dias
                if (d == 4 || d == 6 || d == 9 || d == 11) {
                if (b == 31) err = 1;
        }

        // fevereiro
        if (d == 2){
                // feb
                var g = parseInt(f / 4);
                if (isNaN(g)) {
                        err = 1;
                }
                if (b > 29) err = 1;
                if (b == 29 && ((f / 4) != parseInt(f / 4))) err = 1;
        }
        }

        if (err == 1) {
                return false;
        } else {
                return true;
        }
}

/*********************************************************
* FUNÇÃO CRIADA PARA VALIDAR CGC                         *
*********************************************************/
function Valida_CGC(valor){

		//Funcão criada em 11/10/2001 - 10:00 às 16:56 por Elpidio N Lima Junior 9319-9514
		//Calcula se o CNPJ é válido.
			
		var cgc;
        var retorno;
		var a;
		var j;
		var i;
		var d1;
		var d2;		

		cgc="";    
	
		for (i = 0; i < valor.length; i++) {
			ch = valor.substring(i, i+1);
			if ((ch >= "0" && ch <= "9")) {
					cgc += ch;
			}
		}        
			
	
	   if(cgc.length == 14 && cgc > 0){
		  a = 0;
		  i = 0;
		  d1 = 0;
		  d2 = 0;
		  j = 5;
		 
		 //primeiro dígito
		  for (i = 0; i < 12; i++){                	                	
			a = eval(a + parseInt(eval(parseInt(cgc.substring(i, i+1)) *  j)));
			if (j > 2 ){
				j--;
			}else{
				j=9;
			}	
		  }
					  
		  a = dividirCGC(a);			  
		  if(a > 1){d1=11 - a;}else{d1=0;}

		  a = 0;
		  i = 0;
		  j = 6;
		
		//segundo digito		
		  for (i = 0; i < 13;i++ ){
			a = eval(a + parseInt(eval(parseInt(cgc.substring(i, i+1)) *  j)));

			if (j > 2){
				j--;
			}else{
				j=9;
			}
		  }
		  a = dividirCGC(a);// Mod 11
		  if(a > 1){d2=11 - a;}else{d2=0;}
		  
		  //valida os digitos
		  if (d1 == cgc.substring(12, 13) && d2 == cgc.substring(13, 14)){
			 alert("CGC OK!");
		  }else{
			 alert("CGC Inválido");
		  }
		  
	   }else{
		  alert("CGC Inválido");
	   }        
}
function dividirCGC (numero){
	//Funcão criada em 11/10/2001 - 10:00 às 16:56 por Elpidio N Lima Junior 9319-9514
	//Retira o resto da multiplicação de um número
	
	var vNumero;	
	var vResto;
	var ch;
	var i;
	var resultado;
	
	vNumero = eval(numero / 11);
	resultado = "" + vNumero;

	for (i = 0; i < resultado.length; i++) {
        ch = resultado.substring(i, i+1);
		if(ch=="."){
			vResto = Math.round(eval(("0." +(resultado.substring(i+1,i+5)))*11));		
		}
		
    }

	return vResto;
	
}
/*********************************************************
* FUNÇÃO CRIADA PARA VALIDAR CPF                         *
*********************************************************/
function valida_CPF(valor){

        var soma;
        var Resto;
        var i,ii,iii;
        var ch;
        var cpf;

        cpf="";

        for (i = 0; i < valor.length; i++) {
                ch = valor.substring(i, i+1);
                if ((ch >= "0" && ch <= "9")) {
                        cpf += ch;
                }
        }

        //Valida argumento
        if (cpf.length != 11) {
                return false;
        }

        //primeiro dígito
        soma = 0;
        for(i=0; i<9; i++){
                soma += eval(cpf.substring( i, i+1) * (11 - (i+1)));
        }

        Resto = eval(11 - (soma - (parseInt(soma / 11) * 11)));
        if (Resto == 10 || Resto == 11) {Resto = 0;}

        if (Resto != cpf.substring(9, 10)) {
                return false;
        }

        //segundo dígito
        soma = 0;
        for(i=0; i<10; i++){
                soma += eval(cpf.substring( i, i+1) * (12 - (i+1)));
        }

        Resto = eval(11 - (soma - (parseInt(soma / 11) * 11)));
        if (Resto == 10 || Resto == 11 ){ Resto = 0;}

        if (Resto != cpf.substring(10, 11)) {
                return false;
        }

        //verifica se os numero são iguais.  111... ou 222... etc
        ii=0;
        for (i=0; i < cpf.length; i++){
                if (cpf.substring(i, i+1) == cpf.substring(0, 1)){
                        ii++;
                }
        }
        if (ii == 11){ return false;}
        return true;
}

/*********************************************************
* FUNÇÃO CRIADA PARA VALIDAR PIS                         *
*********************************************************/
function Valida_PIS(pValor){

        var valor = pValor;
        var iValor = extrair_numero(valor);
        if (iValor == "" || iValor < 10) return;
        var iSoma = 0;
        var bValido = false;		

        iSoma = parseInt(iValor.substring(0,1))  * 3 +
                parseInt(iValor.substring(1,2))  * 2 +
                parseInt(iValor.substring(2,3))  * 9 +
                parseInt(iValor.substring(3,4))  * 8 +
                parseInt(iValor.substring(4,5))  * 7 +
                parseInt(iValor.substring(5,6))  * 6 +
                parseInt(iValor.substring(6,7))  * 5 +
                parseInt(iValor.substring(7,8))  * 4 +
                parseInt(iValor.substring(8,9))  * 3 +
                parseInt(iValor.substring(9,10)) * 2;

        iNum = 11 - (iSoma % 11);
        if (iNum > 9) iNum = 0;
        if (iNum == iValor.substring(10,11)) bValido = true;
        
        if (!bValido) {
               return false;
        }

	  return true;
}

/***************************************
* Função para validar email!           *
***************************************/
function e_email(email){

        var i, iArroba
        iArroba=0;

        for(i = 0; i < email.length; i++){
                if ( email.substring(i,i+1) =="@" ){
                        iArroba++;
                }
        }

        if(email != ""){			
                if(email.indexOf("@") <= 0
                || email.indexOf(".") <= 0
                || email.indexOf(",") >= 0
                || email.indexOf("?") >= 0
                || email.indexOf("!") >= 0
                || email.indexOf("#") >= 0
                || email.indexOf("$") >= 0
                || email.indexOf("%") >= 0
                || email.indexOf("^") >= 0
				|| email.indexOf("'")>= 0				
				|| email.indexOf("´")>= 0								
				|| email.indexOf("`")>= 0								
				|| email.indexOf("~")>= 0												
                || email.indexOf("&") >= 0
                || email.indexOf("*") >= 0
                || email.indexOf("(") >= 0
                || email.indexOf(")") >= 0
                || email.indexOf("=") >= 0
                || email.indexOf("{") >= 0
                || email.indexOf("}") >= 0
                || email.indexOf("[") >= 0
                || email.indexOf("]") >= 0
                || email.indexOf("<") >= 0
                || email.indexOf(">") >= 0
                || email.indexOf(":") >= 0
                || email.indexOf(";") >= 0
                || email.indexOf("'") >= 0
                || email.indexOf("`") >= 0
                || email.indexOf("~") >= 0
                || email.indexOf("/") >= 0
                || email.indexOf("\\")>= 0
                || email.indexOf("|") >= 0
                || email.indexOf("@.")>= 0
                || email.indexOf(".@")>= 0
                || email.indexOf("..")>= 0
                || email.indexOf(" ") >= 0
                || iArroba >1
                || email.substring(email.length-1,email.length)=="."){
                        return false;
                }
        }

        return true;
}

/*SUBTITUI UM VALOR PELO OUTRO*/
function iReplace(pTexto, pAcha, pSubstituir){
	
	var novo_valor = "";
	for (i=0;i<pTexto.length;i++){
      	if (pTexto.substring(i,i+1)==pAcha){
            	novo_valor+=pSubstituir;
            }else{
			novo_valor+=pTexto.substring(i,i+1);
		}
      }
	return novo_valor;
}

function validacoesTEXT(pValor){
	var novoValor = iReplace(pValor,'\'','´');
	novoValor = tira_espacos(novoValor,'P'); 
	return novoValor;
}