
-- Storeprocedure {f_cnpjcpf(integer,bpchar)} Versao {001} Esquema {padrao} Descricao {Validar o n�mero do documento especificado(CPF,CNPJ)}
-- ------------------------------------------------------------

/*********************************************************
 Argumentos:
 Pessoa [Juridica(0),Fisica(1) ou
 Livre(2)] (integer), N�mero com digitos
 verificadores e sem pontuacao (bpchar)
 Retorno:
 1: Tipo de Documento invalido.
 2: Caracter invalido no numero do documento.
 3: Numero do Documento invalido.
 1: OK (smallint)
*****************************************************/

CREATE OR REPLACE FUNCTION padrao.f_cnpjcpf (integer,bpchar)
RETURNS integer AS 
'
DECLARE
   pTipo         ALIAS FOR $1;
   pNumero       ALIAS FOR $2;
   i             INT4;
   iProd         INT4;
   iMult         INT4;
   iDigito       INT4;
   sNumero       VARCHAR(20);
BEGIN
   IF (pTipo < 0) OR (pTipo > 2) THEN
      RETURN -1;
   END IF;
   IF pTipo = 2 THEN
      RETURN 1;
   END IF;
   sNumero := trim(pNumero);
   FOR i IN 1..char_length(sNumero) LOOP
      IF position(substring(sNumero, i, 1) in ''1234567890'') = 0 THEN
         RETURN -2;
      END IF;
   END LOOP;
   sNumero := '''';

   IF (char_length(trim(pNumero)) = 14) AND (pTipo = 0) THEN
      sNumero := substring(pNumero from 1 for 12);
      iMult := 2;
      iProd := 0;

      FOR i IN REVERSE 12..1 LOOP
         iProd := iProd + to_number(substring(sNumero from i for 1),''9'') * iMult;
         IF iMult = 9 THEN
            iMult := 2;
         ELSE
            iMult := iMult + 1;
         END IF;
      END LOOP;

      iDigito := 11 - (iProd % 11);
      IF iDigito >= 10 THEN
         iDigito := 0;
      END IF;

      sNumero := substring(pNumero from 1 for 12) || trim(to_char(iDigito,''9'')) || ''0'';

      iMult := 2;
      iProd := 0;

      FOR i IN REVERSE 13..1 LOOP
         iProd := iProd + to_number(substring(sNumero from i for 1),''9'') * iMult;
         IF iMult = 9 THEN
            iMult := 2;
         ELSE
            iMult := iMult + 1;
         END IF;
      END LOOP;

      iDigito := 11 - (iProd % 11);
      IF iDigito >= 10 THEN
         iDigito := 0;
      END IF;

      sNumero := substring(sNumero from 1 for 13) || trim(to_char(iDigito,''9''));
   END IF;

   IF (char_length(trim(pNumero)) = 11) AND (pTipo = 1) THEN
      iDigito := 0;
      iProd := 0;
      sNumero := substring(pNumero from 1 for 9);

      FOR i IN 1..9 LOOP
         iProd := iProd + (to_number(substring(sNumero from i for 1),''9'') * (11 - i));
      END LOOP;
      iDigito := 11 - (iProd % 11);
      IF (iDigito) >= 10 THEN
         iDigito := 0;
      END IF;
      sNumero := substring(pNumero from 1 for 9) || trim(to_char(iDigito,''9'')) || ''0'';
      iProd := 0;
      FOR i IN 1..10 LOOP
         iProd := iProd + (to_number(substring(sNumero from i for 1),''9'') * (12 - i));
      END LOOP;
      iDigito := 11 - (iProd % 11);
      IF (iDigito) >= 10 THEN
         iDigito := 0;
      END IF;
      sNumero := substring(sNumero from 1 for 10) || trim(to_char(iDigito,''9''));

   END IF;
   IF pNumero = sNumero::bpchar THEN
      RETURN 1;
   ELSE
      RETURN -3;
   END IF;
END;
'
LANGUAGE 'plpgsql' VOLATILE;

-- Tabela {view_transacao} Versao {002} Esquema {Empresa} Descricao {VIEW Transacao e Diretivas de lancamento}
-- -----------------------------------------------------------------------------------------------------------

CREATE VIEW view_transacao AS
SELECT fat_transacao_dr."fat_transacao_d_fat_transacao_id" AS codigo_transacao,
	   CAST(trim(to_char(fat_transacao_dr."fat_transacao_d_fat_diretiva_id",'999'))|| trim(to_char(fat_transacao_dr."diretiva_regra_id",'999')) AS INT) AS diretiva,
	   fat_transacao."descricao" AS descricao_transacao,
	   fat_diretiva_regra."descricao" AS regra,
	   fat_transacao_dr."diretiva_regra_propriedade" AS propriedade, 
	   fat_transacao_dr."fat_transacao_d_fat_diretiva_id" AS codigo_diretiva, 
	   fat_transacao_dr."diretiva_regra_id" AS codigo_regra,
	   fat_diretiva."descricao" AS diretiva_descricao
  FROM fat_transacao_dr 
 INNER  
  JOIN fat_transacao ON fat_transacao."id" = fat_transacao_dr."fat_transacao_d_fat_transacao_id"
 INNER 
  JOIN padrao.fat_diretiva ON fat_transacao_dr."fat_transacao_d_fat_diretiva_id" = fat_diretiva."id"
 INNER
  JOIN padrao.fat_diretiva_regra ON fat_transacao_dr."diretiva_regra_id" = fat_diretiva_regra."id" AND fat_diretiva_regra."fat_diretiva_id" = fat_diretiva."id" 
 ORDER 
    BY codigo_transacao, codigo_diretiva, codigo_regra;

-- Storeprocedure {isdiautil(date, int4, varchar)} Versao {001} Esquema {padrao} Descricao {Checa dia util}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.isdiautil( date,  int4,  varchar) RETURNS bool AS
$BODY$
 DECLARE
 p_data          alias for $1;
 p_municipio     alias for $2;
 p_diasuteis     alias for $3;
 v_diasuteis     varchar(7);
 v_retorna       boolean;
 v_dia           varchar(1);
 BEGIN
   v_dia       = to_char(p_data,'D');  -- 1-Domingo 2-Segunda 3-Quarta ... 7-Sabado
   v_diasuteis = p_diasuteis;
   If v_diasuteis is null then
      v_diasuteis = '23456';
   end if;
   If feriado(p_data, p_municipio, false) or not trim(v_diasuteis) like '%'||v_dia||'%' then
      v_retorna = false;
   Else
      v_retorna = true;
   end if;
    RETURN v_retorna;
 END;
 $BODY$
LANGUAGE 'plpgsql' VOLATILE;


-- Storeprocedure {getlastday(date)} Versao {001} Esquema {padrao} Descricao {Retorna Ultimo dia do mes}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.getlastday( date) RETURNS date AS
$BODY$
 DECLARE
 p_data        ALIAS FOR $1;
 v_data	      date;
 BEGIN
    v_data = p_data + interval '1 month';     -- avanca para o pr�ximo m�s
    v_data = DATE_TRUNC('month', v_data)::date - 1; -- trunca no m�s e retorna um dia voltando para o ultimo dia do mes anterior
    RETURN v_data;
 END;
 $BODY$
LANGUAGE 'plpgsql' IMMUTABLE;

-- Storeprocedure {getfirstday(date)} Versao {003} Esquema {padrao} Descricao {Retorna Primeiro dia do mes}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.getfirstday( date) RETURNS date AS
$BODY$
DECLARE
 p_data        ALIAS FOR $1;
 v_data	      date;
 BEGIN
    v_data = DATE_TRUNC('month', p_data)::date; -- trunca no m�s
    RETURN v_data;
 END;
$BODY$
LANGUAGE 'plpgsql' IMMUTABLE;

-- Storeprocedure {getpreco(int4,  int4,  int4)} Versao {004} Esquema {padrao} Descricao {Retorna precco}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.getpreco( int4,  int4,  int4) RETURNS Numeric(12,2) AS
$BODY$
DECLARE
 v_lispre_codigo         alias for $1;
 v_codigotabela          alias for $2;
 v_produto               alias for $3;
 r_resultado             RECORD;
 v_retornar              float8;
 BEGIN
    v_retornar := 0;
   
    select * 
      into r_resultado 
      from fat_produto_preco
     where fat_produto_preco.fat_produto_id = v_produto       
       and fat_produto_preco.fat_listapre_tabela_fat_listapre_id = v_lispre_codigo 
       and fat_produto_preco.fat_listapre_tabela_tabela_id  = v_codigotabela;
       
    If found then
       v_retornar := r_resultado.preco;
    End if;
    RETURN v_retornar;
 END;
 $BODY$
LANGUAGE 'plpgsql';

-- Storeprocedure {getultimaalteracaopreco(int4,  int4,  int4)} Versao {005} Esquema {padrao} Descricao {Retorna precco}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.getultimaalteracaopreco( int4,  int4,  int4) RETURNS TIMESTAMP AS
$BODY$
DECLARE
 v_lispre_codigo         alias for $1;
 v_codigotabela          alias for $2;
 v_produto               alias for $3;
 r_resultado             RECORD;
 v_retornar              TIMESTAMP;
 BEGIN
    --v_retornar := null;
   
    SELECT dthaud 
      INTO r_resultado 
      FROM auditoria 
     WHERE tabaud = 'fat_produto_preco' 
       AND (tacaud = 'UPDATE' OR tacaud = 'INSERT') 
       AND v_produto       = vpkaud[1]::INT 
       AND v_codigotabela  = vpkaud[2]::INT 
       AND v_lispre_codigo = vpkaud[3]::INT 
     ORDER BY dthaud DESC, pkyaud DESC LIMIT 1;
     
    If found then
       RETURN r_resultado.dthaud;
    End if;
    RETURN v_retornar;
 END;
 $BODY$
LANGUAGE 'plpgsql';

-- Storeprocedure {getdiasuteis(date,  date,  varchar)} Versao {001} Esquema {padrao} Descricao {Retorna dias uteis}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.getdiasuteis( date,  date,  varchar) RETURNS int8 AS
$BODY$
DECLARE
 p_dataInicial    alias for $1;
 p_dataFinal      alias for $2;
 p_diasuteis      alias for $3;
 v_data           date;
 v_retorno        int8;
 BEGIN
   v_data := p_dataInicial;
   v_retorno := 0;
   WHILE v_data <= p_dataFinal LOOP
     if isdiautil(v_data, null, p_diasuteis) is true then
       v_retorno := v_retorno + 1;
     end if;
     v_data := v_data + 1;
   END LOOP;
   RETURN v_retorno;
 END;
$BODY$
LANGUAGE 'plpgsql';

-- Storeprocedure {getestoque(int4,  int4, date)} Versao {012} Esquema {padrao} Descricao {Retorna estoque}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.getestoque( int4,  int4, date) RETURNS float8 AS
$BODY$
DECLARE
 v_filial                alias for $1;
 v_produto               alias for $2;
 v_database              alias for $3;
 v_retornar              float8;
 v_recno                 BigInt;
 r_resultado             RECORD;
 mSaldo                  NUMERIC(16,4);
 mSaldo2                 NUMERIC(16,4);
 mSaldoInv               NUMERIC(16,4);

 filial integer;
 filial2 integer;


 r_filial         RECORD;
 r_parameters     RECORD;  
 
 BEGIN
   v_retornar := 0;

   --Posiciona parameters
	 SELECT *
	   INTO r_parameters 
	   FROM fat_parameters 
	  LIMIT 1 ;    

    --posiciona filial
    SELECT id, filialestoque
	  INTO r_filial
      FROM cad_filial
	 WHERE id = v_Filial;

    filial  = r_filial.id;
	filial2 = r_filial.filialestoque;

   -- acha saldo inicial
   SELECT saldo,     saldo2,   saldoinventario
     INTO r_resultado
     FROM fat_produto_movto
    WHERE (cad_filial_id  = filial OR fat_produto_movto.cad_filial_id  = filial2)
      AND fat_produto_id    = v_Produto
      AND DataMovto        <= v_DataBase
    ORDER BY DataMovto DESC, fat_docto_c_controle DESC 
    LIMIT 1;

   IF FOUND THEN
      mSaldo          = r_resultado.saldo;
      mSaldo2         = r_resultado.saldo2;
      mSaldoInv       = r_resultado.saldoinventario;
   ELSE
      mSaldo          = 0;
      mSaldo2         = 0;
      mSaldoInv       = 0;
   END IF;

   v_retornar := mSaldo;
   RETURN v_retornar;
 END;
$BODY$
LANGUAGE 'plpgsql';

-- Storeprocedure {getestoque(int4,  int4)} Versao {012} Esquema {padrao} Descricao {Retorna estoque na data atual}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.getestoque( int4,  int4) RETURNS float8 AS
$BODY$
DECLARE
 v_filial                alias for $1;
 v_produto               alias for $2;
 v_database              Date;
 v_retornar              float8;
 v_recno                 BigInt;
 r_resultado             RECORD;
 mSaldo                  NUMERIC(16,4);
 mSaldo2                 NUMERIC(16,4);
 mSaldoInv               NUMERIC(16,4);

 filial integer;
 filial2 integer;


 r_filial         RECORD;
 r_parameters     RECORD;  

 BEGIN
   v_retornar := 0;
   v_database := CURRENT_DATE;
   
   --Posiciona parameters
	 SELECT *
	   INTO r_parameters 
	   FROM fat_parameters 
	  LIMIT 1 ;    

   --posiciona filial
    SELECT id, filialestoque
	  INTO r_filial
      FROM cad_filial
	 WHERE id = v_Filial;

	filial  = r_filial.id;
	filial2 = r_filial.filialestoque;
   
-- acha saldo inicial
   SELECT saldo,     saldo2,   saldoinventario
     INTO r_resultado
     FROM fat_produto_movto
    WHERE (cad_filial_id  = filial OR fat_produto_movto.cad_filial_id  = filial2)
      AND fat_produto_id    = v_Produto
      AND DataMovto        <= v_DataBase
    ORDER BY DataMovto DESC, fat_docto_c_controle DESC
    LIMIT 1;

   IF FOUND THEN
      mSaldo          = r_resultado.saldo;
      mSaldo2         = r_resultado.saldo2;
      mSaldoInv       = r_resultado.saldoinventario;
   ELSE
      mSaldo          = 0;
      mSaldo2         = 0;
      mSaldoInv       = 0;
   END IF;

   v_retornar := mSaldo;
   RETURN v_retornar;
 END;
$BODY$
LANGUAGE 'plpgsql';

-- Storeprocedure {geticms(int4,  char(2), integer)} Versao {012} Esquema {padrao} Descricao {Aliquota Icms }
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.geticms( int4,  CHAR(2), integer) RETURNS float8 AS
$BODY$
DECLARE
 v_aliquota_codigo               alias for $1;
 v_uf                            alias for $2;
 v_campo                         alias for $3; -- 1)Aliq_icms_Contribuinte 2)Aliq_icms_NaoContribuinte 2)Aliq_dif_Contribuinte 3)Aliq_dif_NaoContribuinte 3)
 v_retornar                      float8;
 v_recno                         BigInt;
 r_resultado                     RECORD;
 r_parameters                    RECORD;
 r_filial                        RECORD;
 maliquota_icms_contribuinte     NUMERIC;
 maliquota_icms_naocontribuinte  NUMERIC;
 maliquota_dif_contribuinte      NUMERIC;
 maliquota_dif_naocontribuinte   NUMERIC;
 maliquota_mva                   NUMERIC; --)5
 mfator_mva                      NUMERIC; --)6
 mreducao_base                   NUMERIC; --)7
 maliq_dest_id                    float8; --)8

 BEGIN
   v_retornar := 0;
--Posiciona parameters
	SELECT *
	INTO r_parameters
	FROM fat_parameters
	LIMIT 1 ;

--Posiciona filial
   SELECT id, cast(substring(regimetributacao from 1 for 1) AS CHAR(1)) as trib
     INTO r_filial
	 FROM cad_filial
	WHERE id = r_parameters.fatfilialpadrao;

	--IF r_filial.trib = 'S' THEN
	--   RETURN v_retornar;
	--END IF;

-- acha aliquota
   SELECT aliquota_icms_contribuinte, aliquota_icms_naocontribuinte,
          aliquota_dif_contribuinte, aliquota_dif_naocontribuinte,
          aliquota_mva, fator_mva,
          reducao_base, aliq_dest_id
     FROM padrao.cad_estado_trib
     INTO r_resultado
    WHERE fat_aliquotas_id = v_aliquota_codigo
      AND uf = v_uf
    LIMIT 1;

   IF FOUND THEN
      IF v_campo = 1 THEN --Aliq_icms_Contribuinte
         v_retornar =  r_resultado.aliquota_icms_contribuinte;
      END IF;
      IF v_campo = 2 THEN --Aliq_icms_NaoContribuinte
         v_retornar =  r_resultado.aliquota_icms_naocontribuinte;
      END IF;
      IF v_campo = 3 THEN --Aliq_dif_Contribuinte
         v_retornar =  r_resultado.aliquota_dif_contribuinte;
      END IF;
      IF v_campo = 4 THEN --Aliq_dif_NaoContribuinte
         v_retornar =  r_resultado.aliquota_dif_naocontribuinte;
      END IF;
      IF v_campo = 5 THEN --
        v_retornar =  r_resultado.aliquota_mva;
      END IF;
      IF v_campo = 6 THEN --
        v_retornar =  r_resultado.fator_mva;
      END IF;
      IF v_campo = 7 THEN --
        v_retornar =  r_resultado.reducao_base;
      END IF;
      IF v_campo = 8 THEN --
        v_retornar =  r_resultado.aliq_dest_id;
      END IF;
   END IF;
   RETURN v_retornar;
 END;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;

-- Storeprocedure {getTextoPadrao(int4,  char(2), integer)} Versao {002} Esquema {padrao} Descricao {Retorna texto padaro conforme aliquota }
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.gettextopadrao( int4,  CHAR(2), integer) RETURNS TEXT AS
$BODY$
DECLARE
 v_aliquota_codigo               alias for $1;
 v_uf                            alias for $2;
 v_campo                         alias for $3; -- 1)TextoPadrao 2)TextoPadraoDiferimentoParcial
 v_retornar                      TEXT;
 v_recno                         BigInt;
 r_resultado                     RECORD;
 r_parameters                    RECORD;  
 r_filial                        RECORD;   
 maliquota_icms_contribuinte     NUMERIC;
 maliquota_icms_naocontribuinte  NUMERIC;
 maliquota_dif_contribuinte      NUMERIC;
 maliquota_dif_naocontribuinte   NUMERIC;

 BEGIN
   v_retornar := '';
--Posiciona parameters
	SELECT *
	INTO r_parameters 
	FROM fat_parameters 
	LIMIT 1 ;    

--Posiciona filial
   SELECT id, cast(substring(regimetributacao from 1 for 1) AS CHAR(1)) as trib
     INTO r_filial 
	 FROM cad_filial
	WHERE id = r_parameters.fatfilialpadrao;
	
-- acha aliquota
   SELECT textopadrao, textopadrao_dif
     FROM padrao.cad_estado_trib
     INTO r_resultado
    WHERE fat_aliquotas_id = v_aliquota_codigo
      AND uf = v_uf
    LIMIT 1;   
    
   IF FOUND THEN
      IF v_campo = 1 THEN --TextoPadrao
         v_retornar =  r_resultado.textopadrao;
      END IF;
      IF v_campo = 2 THEN --TextoPadraoDiferimentoParcial
         v_retornar =  r_resultado.textopadrao_dif;
      END IF;
   END IF;
   RETURN v_retornar;
 END;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;

-- Storeprocedure {string_integer(varchar)} Versao {001} Esquema {padrao} Descricao {Converte String}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.string_integer(text) RETURNS INTEGER AS
$BODY$
DECLARE
 p_converter       alias for $1;
 v_retornar        integer;
 v_numero          varchar;

 BEGIN
    v_retornar = 0;
    v_numero = substring(p_converter from 1 for 1);
    --RAISE NOTICE 'v_numero: %', v_numero;
    IF v_numero = '0' THEN
       v_retornar = p_converter::INTEGER;
    END IF;
    IF v_numero = '1' THEN
       v_retornar = p_converter::INTEGER;
    END IF;
    IF v_numero = '2' THEN
       v_retornar = p_converter::INTEGER;
    END IF;
    IF v_numero = '3' THEN
       v_retornar = p_converter::INTEGER;
    END IF;
    IF v_numero = '4' THEN
       v_retornar = p_converter::INTEGER;
    END IF;
    IF v_numero = '5' THEN
       v_retornar = p_converter::INTEGER;
    END IF;
    IF v_numero = '6' THEN
       v_retornar = p_converter::INTEGER;
    END IF;
    IF v_numero = '7'THEN 
       v_retornar = p_converter::INTEGER;
    END IF;
    IF v_numero = '8' THEN
       v_retornar = p_converter::INTEGER;
    END IF;
    IF v_numero = '9' THEN
       v_retornar = p_converter::INTEGER;
    END IF;

    return v_retornar;
 END;
 $BODY$
 LANGUAGE 'plpgsql' VOLATILE;

-- Storeprocedure {getsequencia(varchar)} Versao {003} Esquema {padrao} Descricao {Retorna sequencia}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.getsequencia(varchar) RETURNS int8 AS
$BODY$
DECLARE
 p_sequencia      alias for $1;
 v_retorno        int8;
 ref_seq          refcursor;
 r_seq            RECORD;
 BEGIN
    IF p_sequencia ISNULL THEN
        --RAISE NOTICE 'O campo data inicio n�o pode ser nulo.';
        RETURN 0;
    END IF;
     IF p_sequencia = '' THEN
        --RAISE NOTICE 'O campo data inicio n�o pode ser vazio.';
        RETURN 0;
    END IF;	 
   OPEN ref_seq FOR EXECUTE('SELECT last_value AS sequencia FROM '||p_sequencia);
   FETCH ref_seq INTO r_seq;
   IF r_seq.sequencia > 0 THEN
      v_retorno = r_seq.sequencia;
   END IF;
   RETURN v_retorno + 1;
 END;
 $BODY$
LANGUAGE 'plpgsql' VOLATILE;

-- StoreProcedure {gerar_solicitacao()} Versao {015} Esquema {padrao} Descricao {Gerar Solicitacoes de Clientes pelo atendimento}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.gerar_solicitacao()
RETURNS trigger AS
$BODY$
BEGIN
   IF NEW.gerarsolicitacao THEN
      -- Insert or update tabela sugestoes/correcoes row with the new values.
        LOOP
           UPDATE cad_sugestoes
              SET referente = NEW.assunto,
                  usuario   = NEW.usuario,
                  cad_cadastro_id = NEW.cad_cadastro_id,
                  cliente   = NEW.cliente,
                  descricao = NEW.relatorio,
                  doc_html_rtf = NEW.doc_html_rtf,
                  dataalteracao= NEW.dataalteracao,
                  horaalteracao= NEW.horaalteracao,
                  usuarioalteracao= NEW.usuarioalteracao,
                  emissao=NEW.dataatendimento,
                  horaemissao=NEW.hora,
                  solicitante=NEW.solicitante,
                  classificacao_atendimento = NEW.classificacao
              WHERE
              	  cad_atendimento_protocolo = NEW.protocolo;

            EXIT  WHEN found;

            BEGIN
                INSERT INTO cad_sugestoes (	cad_atendimento_protocolo,
                                referente,
                                classificacao,
                                classificacao_atendimento,
                                usuario,
                                cad_cadastro_id,
                                cliente,
                                descricao,
                                doc_html_rtf,
                                datainclusao,
                                horainclusao,
                                usuarioinclusao,
                                emissao,
                                horaemissao,
                                solicitante,
                                prioridade)
                     VALUES (NEW.protocolo,
                             NEW.assunto,
                             'Solicitacao de Clientes',
                             NEW.classificacao,
                             NEW.usuario,
                             NEW.cad_cadastro_id,
                             NEW.cliente,
                             NEW.relatorio,
                             NEW.doc_html_rtf,
                             NEW.datainclusao,
                             NEW.horainclusao,
                             NEW.usuarioinclusao,
                             NEW.dataatendimento,
                             NEW.hora,
                             NEW.solicitante,
                             '1 - Baixa');

                EXIT ;

            EXCEPTION
                WHEN UNIQUE_VIOLATION THEN
                    -- do nothing
            END;
        END LOOP;

   END IF;
   IF NOT NEW.gerarsolicitacao THEN
      DELETE FROM cad_sugestoes WHERE cad_atendimento_protocolo = NEW.protocolo;
   END IF;
   RETURN NULL;
END;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;

-- Gatilho {gerar_solicitacao()} Versao {004} Esquema {empresa} Descricao {Gerar Solicitacoes de Clientes pelo atendimento}
-- ------------------------------------------------------------

CREATE TRIGGER gerar_solicitacao AFTER INSERT OR UPDATE ON cad_atendimento
       FOR EACH ROW EXECUTE PROCEDURE padrao.gerar_solicitacao();

-- StoreProcedure {grava_condpgp()} Versao {017} Esquema {padrao} Descricao {Grava/Sugere parcelas na Tabela CondPgP(condicoes de pgto)}
-- ------------------------------------------------------------

CREATE OR REPLACE FUNCTION padrao.grava_condpgp()
RETURNS trigger AS
$BODY$
DECLARE
   contador    integer;
   totParcelas integer;
BEGIN
   contador := 0;
   totParcelas := NEW.parcelas;
   -- Update o sistema exclui as parcelas para reincluir
   IF TG_OP = 'UPDATE'  THEN
	  IF OLD.parcelas >  NEW.parcelas THEN
	     DELETE FROM fat_condpg_p WHERE fat_condpg_id = NEW.id AND parcela > NEW.parcelas ;
	  END IF;
   END IF;
   -- Insert or update tabela condpgp row with the new values.
   LOOP
       contador := contador + 1;
       EXIT WHEN contador > totParcelas;

       UPDATE fat_condpg_p
          SET diasemissao=30*contador,
              percentual=round(100.00000/totParcelas,5),
              dataalteracao= NEW.dataalteracao,
              horaalteracao= NEW.horaalteracao,
              usuarioalteracao= NEW.usuarioalteracao
        WHERE fat_condpg_id = NEW.id AND parcela = contador;

       BEGIN
          INSERT INTO fat_condpg_p (fat_condpg_id,
                      parcela,
                      diasemissao,
                      percentual ,
                      financ_portador_id,
                      financ_tipocobranca_id,
                      datainclusao,
                      horainclusao,
                      usuarioinclusao)
                 VALUES (NEW.id,
                      contador,
                      30*contador,
                      round(100.00000/totParcelas,5),
                      1,
					  1,
                      NEW.datainclusao,
                      NEW.horainclusao,
                      NEW.usuarioinclusao);

       EXCEPTION
           WHEN UNIQUE_VIOLATION THEN
                    -- do nothing
       END;
   END LOOP;
   RETURN NULL;
END;
$BODY$
LANGUAGE 'plpgsql';


-- Gatilho {grava_condpgp()} Versao {011} Esquema {empresa} Descricao {Grava/Sugere parcelas na Tabela CondPgP(condicoes de pgto-parcelas)}
-- ------------------------------------------------------------

CREATE TRIGGER grava_condpgp AFTER INSERT OR UPDATE ON fat_condpg
       FOR EACH ROW EXECUTE PROCEDURE padrao.grava_condpgp();

       




-- Gatilho {user_sync()} Versao {001} Esquema {padrao} Descricao {Sincroniza Cadastro de Usuarios com o PostgreSQL}
-- ------------------------------------------------------------

CREATE TRIGGER user_sync AFTER INSERT OR UPDATE OR DELETE ON padrao.usuario
       FOR EACH ROW EXECUTE PROCEDURE padrao.user_sync();  
       

-- StoreProcedure {padrao.incluitrib()} Versao {002} Esquema {padrao} Descricao {Inclui Class.Trib. por estado nos produtos}
-- ------------------------------------------------------------

	CREATE OR REPLACE FUNCTION padrao.incluitrib()
	RETURNS bool AS 
	$BODY$
	DECLARE 
	 r_fatproduto RECORD;
	 retorna boolean;
	BEGIN
	 retorna = false;
	 FOR r_fatproduto IN SELECT * FROM fat_produto LOOP
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'PR', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'RS', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'SC', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'SP', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'RJ', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'MG', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'ES', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'MS', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'MT', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'GO', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'DF', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'AC', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'AM', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'AP', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'RR', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'RO', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'PA', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'MA', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'CE', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'PI', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'RN', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'PB', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'PE', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'BA', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'SE', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'AL', 1);
		INSERT INTO fat_produto_classtrib (fat_produto_id, uf, classtributaria_id) VALUES(r_fatproduto.id, 'TO', 1);
		retorna = true;
	 END LOOP;
	 RETURN retorna;
	END;
	
	
	 $BODY$
	
	LANGUAGE 'plpgsql' VOLATILE;

-- Storeprocedure {dados_tabela(varchar)} Versao {009} Esquema {padrao} Descricao {Retorna estrutura de uma tabela}
-- ------------------------------------------------------------

    CREATE OR REPLACE FUNCTION padrao.dados_tabela(varchar(30))
    RETURNS SETOF padrao.tabela_estrutura AS
    '
     DECLARE
     r padrao.tabela_estrutura%ROWTYPE;
     rec RECORD;
     vTabela alias for $1;
     eSql TEXT;

     BEGIN
     eSql := ''SELECT CAST(rel.nspname as TEXT), CAST(rel.relname AS TEXT) , CAST(attrs.attname AS TEXT), CAST("Type" AS TEXT), CAST("Default" AS TEXT), attrs.attnotnull
            FROM
                   (SELECT c.oid, n.nspname, c.relname
                   FROM pg_catalog.pg_class c
                   LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
                   WHERE pg_catalog.pg_table_is_visible(c.oid) ) rel
            JOIN
                   (SELECT a.attname, a.attrelid,
                   pg_catalog.format_type(a.atttypid, a.atttypmod) as "Type",
                          (SELECT substring(d.adbin for 128) FROM pg_catalog.pg_attrdef d
                          WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef)
                   as "Default", a.attnotnull, a.attnum
                   FROM pg_catalog.pg_attribute a
                   WHERE a.attnum > 0 AND NOT a.attisdropped ) attrs
            ON (attrs.attrelid = rel.oid )
            WHERE relname LIKE ''''%'' || vTabela || ''%''''
            ORDER BY attrs.attnum'';
    FOR r IN EXECUTE eSql
     LOOP
     RETURN NEXT r;
    END LOOP;
     IF NOT FOUND THEN
            RAISE EXCEPTION ''Tabela % nao encontrada'', vTabela;
     END IF;
     RETURN;
     END
     '
     LANGUAGE 'plpgsql';
