25/03/2020 | Coronavírus - Como adequar o seu Gestão de Pessoas para a MP 927

Texto alterado em: 09/11/2020. Editado o item Transferência dos valores de férias MP 927.

Atenção

A vigência da MP 927 encerrou dia 19/07/2020. Portanto, a partir de 20/07/2020, não será mais permitido realizar o cálculo de férias com pagamento do 1/3 futuro.

Veja AQUI o que fazer no seu sistema.

Para mais informações sobre o término da vigência, leia esta notícia.

Conforme comunicamos no dia 23, a Medida Provisória 927 de 22/03/2020 permite a flexibilização de algumas rotinas realizadas através do sistema Gestão de Pessoas.

AVISO IMPORTANTE

É imprescindível que sempre sejam realizados testes e validações antes da aplicação desses procedimentos no seu ambiente em produção.

Este conteúdo procura abranger o cenário mais frequente e cabe a cada empresa analisar os impactos de acordo com as características específicas do seu negócio.

Pagamento do Evento de 1/3 de Férias Covid-19

O Evento de 1/3 de Férias Covid-19, conforme a MP 927/20, poderá ser pago no mesmo prazo do 13º Salário, ou seja, até a data de 18/12/2020.

O eSocial não aceita o tipo de incidência da rubrica de férias na Folha tipo 32 - 13º Salário Integral e, por isso, o evento de 1/3 de Férias do Covid-19 não poderá ser lançado nessa Folha;
Para que o pagamento seja realizado na Folha do tipo 11 - Pagamento Mensal, o pagamento deverá ser efetuado até a competência 11/2020;
Caso a Empresa opte por pagar o valor de 1/3 de Férias do Covid-19 após o pagamento da Folha mensal 11/2020, o pagamento deverá ser feito em uma Folha específica com data de pagamento até dia 18/12/2020, e deverá utilizar a Folha de cálculo do tipo 93 - Especiais, exclusiva para esse pagamento. No entanto, é necessário que o sistema esteja atualizado com as versões 6.2.34.104 ou 6.2.35.38, previstas para serem liberadas no dia 06/11/2020.

Importante: o lançamento do Evento deve seguir o mesmo processo já documentado na matéria referente à MP 927, item Pagamento Evento 1/3 de Férias Covid-19.

Capítulo III - DA ANTECIPAÇÃO DE FÉRIAS INDIVIDUAIS, Artigos 8 e 9

Durante a vigência da MP 927

O que pode ser feito no Gestão de Pessoas | HCM:

Cálculo Recibo de Férias

A solução encontrada para atender emergencialmente foi através de regra especial e criação de eventos. Segue detalhamento do processo que deverá ser feito no sistema:

Criar uma regra especial com as informações abaixo e vincular no novo evento de 1/3.

Definir Numero xNumEmp;
Definir Numero xTipCol;
Definir Numero xNumCad;
Definir Numero xCodEve;
Definir Numero xCodTab;
Definir Numero xAchou;
Definir data dIniPer;
Definir data dIniFer;
Definir data dIniCovid;
MontaData (22,03,2020,dIniCovid);                   

@ Calculo refere ao recibo de ferias Normal e Coletiva@
Se ((tipCal >= 51) e (tipCal <= 53))
inicio
  @ Caso não seja referente a MP COVID19 zera o evento@
  Se (((R040FEM.GerAdt = 'S') e (R040FEM.PrvDes <> 0.01)) ou ((R040FEM.GerAdt = 'N') e (R040FEM.IniFer < dIniCovid)))
     valEvt = 0;
fim
senao 
Se (tipCal = 54)@ Integração das ferias com a Folha@
inicio 
  xNumEmp = r034fun.NumEmp;
  xTipCol = r034fun.TipCol;
  xNumCad = r034fun.NumCad;
  xCodEve = codEvt;
  dIniPer = r040fem.IniPer;
  dIniFer = r040fem.IniFer;  
           
  @ busca Recibo de ferias Colaborador @
  Definir cursor cur_R040Fem;
  cur_R040Fem.SQL "select PrvDes, IniFer, GerAdt from R040Fem \
                 Where NumEmp = :xNumEmp and TipCol = :xTipCol and NumCad = :xNumCad and IniPer = :dIniPer and IniFer = :dIniFer";
  cur_R040Fem.AbrirCursor();
  Se (cur_R040Fem.Achou)
  inicio
  @ Caso não seja referente a MP COVID19 zera o evento@
   Se (((cur_R040Fem.GerAdt = 'S') e (cur_R040Fem.PrvDes <> 0.01)) ou ((cur_R040Fem.GerAdt = 'N') e (cur_R040Fem.IniFer < dIniCovid)))
   inicio
     valEvt = 0;
   fim
   senao
   inicio
      @ Se recibo com adiantamtamento e for MP COVID19 @
      Se ((cur_R040Fem.GerAdt = 'S') e (cur_R040Fem.PrvDes = 0.01))
      inicio
         xAchou = 0;
         Definir cursor cur_R030Emp;
         cur_R030Emp.SQL "select CalDpn, TabEve from R030Emp Where NumEmp = :xNumEmp";
         cur_R030Emp.AbrirCursor();
         @Busca assinalmento da empresa pra a rotina de Diferenca Positiva/Negativa de Ferias@
         Se (cur_R030Emp.Achou)
         Inicio
            @Caso utilize a rotina mas não tenha evento configurado trata valor no evento normal de diferença @
            se (cur_R030Emp.CalDpn = 'S')
            inicio            
               xCodTab = cur_R030Emp.TabEve;
               Definir cursor cur_R008Evc;
               cur_R008Evc.SQL "select * from R008Evc Where CodTab = :xCodTab and CodEve = :xCodEve and EveDpo > 0";
               cur_R008Evc.AbrirCursor();
               Se (cur_R008Evc.Achou)
               inicio
                 xAchou = 1;
               fim
               cur_R008Evc.FecharCursor();
            fim        
         fim
        cur_R030Emp.FecharCursor();
        
        @ Caso não use a rotina de Diferenca Positiva/Negativa ou nao tenha o evento calculado, busca o valor original calculado no recibo de ferias@ 
         se (xAchou = 0)
         inicio
           Definir cursor cur_R040Fev;
           cur_R040Fev.SQL "select ValEve from R040Fev \
                   Where NumEmp = :xNumEmp and TipCol = :xTipCol and NumCad = :xNumCad and IniPer = :dIniPer and IniFer = :dIniFer and CodEve = :xCodEve";
           cur_R040Fev.AbrirCursor();
           Se (cur_R040Fev.Achou)
           inicio
              valEvt = cur_R040Fev.ValEve;
           fim
           cur_R040Fev.FecharCursor();
         fim      
      fim
   fim       
  fim
  cur_R040Fem.FecharCursor();
fim
senao
inicio
   valEvt = 0;
fim;

IMPORTANTE: O efeito da MP 927 na regra está a partir data de sua publicação (22/03/20). Caso o início do efeito da MP 927 na sua empresa seja em data anterior ou posterior, deverá ser ajustado a data na regra, linha:

MontaData (22,03,2020,dIniCovid);

Uma vez a data ajustada e iniciado o calculo de férias neste modelo, a data na regra não poderá mais ser ajustada.

CLC a ser cadastrado para este evento:

Nota: O código deve ser um número que estiver livre na sua tabela de CLC.

Evento:

Exemplos de Recibo de Férias e Ficha Financeira com o novo evento de 1/3:

Recibo de férias:

A Ficha Financeira:

Cálculo das provisões/contabilização

Colaboradores / Provisões / Férias

Na tela de Provisão o valor do 1/3 de férias + encargos, dos dias de férias que estão sendo concedidos no mês serão baixados do saldo da provisão, e consequentemente serão efetuados estes lançamentos na contabilização da Folha.

A solução para estornar a baixa dos valores do 1/3 de férias nas contas contábeis, se dará através de:

CLC do evento novo para o desconto do 1/3 de férias no recibo e na Folha
Novos CLC’s para tratamento dos encargos
Regra especial para CLC dos encargos

Os novos CLCs lançarão de volta nas contas contábeis o valor do 1/3 férias + encargos, deixando o saldo das contas corretas. O valor do 1/3 será baixado na contabilização no mês em que a empresa o pagar, limite dia 20/12.

Desta forma, o valor demonstrado na tela de Provisão do colaborador estará a menor, tendo em vista que o sistema não terá como ajustar isto agora. Contudo, nos lançamentos para a contabilidade, os valores estarão corretos.

Novos CLCs

Importante:

Este CLC não precisa ser criado quando no cadastro do evento de 1/3 de férias constar a incidência “N” no campo INSS Mensal.

Importante:

Este CLC não precisa ser criado quando no cadastro do evento de 1/3 de férias constar a incidência “N” no campo INSS Mensal.

Observação

O campo Nível de lançamento pode ser adequado de acordo com o entendimento do contador da empresa.

Importante

Para os clientes que utilizam Rateio, o nível de lançamento do CLC 63 deve ser por Centro de Custo para que a Contabilização seja realizada corretamente.
Para as empresas que utilizam Partidas Dobradas, torna-se necessário para as configurações de CLCs, que sejam criados outros CLCs de contrapartida. Ou seja, para todos os CLCs, deverá ser criado no mesmo nível, outro CLC com tipo de lançamento diferente. Sendo que o CLC normal deverá constar na base do CLC criado.

Contabilização por partidas dobradas

Para os CLCs 63 e 71, outro CLC com tipo de lançamento diferente deverá ser criado no mesmo nível. Exemplo:

CLC	Descrição	Tipo do Lançamento	Nível do Lançamento
Normal: 63	Desconto 1/3 Férias Covid-19	"C"	"T"
Contra-partida: 163	Desconto 1/3 Férias Covid-19	"D"	"T"

Além disso, devem ser criados dois novos CLCs com a mesma configuração que os CLCs 63 e 71. Por exemplo:

CLC 64 com a mesma configuração que o 63, exceto pelo tipo de base que deve ser "C", e vincular o CLC 63 neste CLC 64. No evento de contra-partida criado (163), inserir o CLC 64 na base.

No momento de informar as contas, deixar os CLCs 63 e 71 sem contas e informá-las nos CLCs 64 e 72.

Observação

O campo Nível de lançamento pode ser adequado de acordo com o entendimento do contador da empresa.

Regra para o CLC de FGTS

/* Regra para reversão dos valores de FGTS sobre 1/3 de férias MP 927 */
/* Compilação: 01/04/2020 */

/* Definição dos Cursores de Pesquisa */
Definir Alfa CurR146Prv;

/* Definição da Variaveis globais */
Definir Numero vNumEmp;
Definir Numero vTipCol;
Definir Numero vNumCad;
Definir Numero vTipPrv;
Definir Numero vTipVal;
Definir Numero vPerVal;
Definir Numero vValClc;
Definir Data   vPerRef;

/* Inicialização da Varivies Globais */
vNumEmp = R048Ctb.NumEmp;
vTipCol = R048Ctb.TipCol;
vNumCad = R048Ctb.NumCad;
vTipPrv = 1;  @ Defini que é exclusivo para a provisão de férias @
vTipVal = 4;  @ Defini que é exclusivo para o FGTS @
vPerVal = 0;
vValClc = R048Ctb.ValLan;
vPerRef = PerRef;

/* Pesquisa o percentual de FGTS aplicado no último calculo realizado da provisão */
SQL_Criar(CurR146Prv);
SQL_UsarAbrangencia(CurR146Prv,0); 
SQL_USARSQLSENIOR2(CurR146Prv,0);  
SQL_DefinirComando(CurR146Prv,"Select PerVal From R146Prv B \
                               where B.NumEmp = :vNumEmp \
                                 and B.Tipcol = :vTipCol \
                                 and B.NumCad = :vNumCad \
                                 and B.TipPrv = :vTipPrv \
                                 and B.TipVal = :vTipVal \
                                 and B.MesAno = (Select Max(A.MesAno) From R146Prv A \
                                                 Where B.NumEmp = A.NumEmp \
                                                   and B.TipCol = A.TipCol \
                                                   and B.NumCad = A.NumCad \
                                                   and B.TipPrv = A.TipPrv \
                                                   and B.TipVal = A.TipVal \
                                                   and A.MesAno <= :vPerRef)");
SQL_DefinirInteiro(CurR146Prv,"vNumEmp",vNumEmp);
SQL_DefinirInteiro(CurR146Prv,"vTipCol",vTipCol);
SQL_DefinirInteiro(CurR146Prv,"vNumCad",vNumCad);
SQL_DefinirInteiro(CurR146Prv,"vTipPrv",vTipPrv);
SQL_DefinirInteiro(CurR146Prv,"vTipVal",vTipVal);
SQL_DefinirData(CurR146Prv,"vPerRef",vPerRef);
SQL_AbrirCursor(CurR146Prv);
Enquanto (SQL_EOF(CurR146Prv) = 0)
  Inicio
  SQL_RetornarFlutuante(CurR146Prv, "PerVal", vPerVal);
  SQL_Proximo(CurR146Prv);      
  Fim;
SQL_FecharCursor(CurR146Prv);    
SQL_Destruir(CurR146Prv);

/* Apura o valor a ser atibuido ao CLC */
vValClc = (vValClc * vPerVal) / 100;
ArredondarValor(vValClc, 2); @ Arredonda o valor para duas casas decimais @

R048Ctb.ValLan = vValClc; @ Atribui o valor do lançamento contábil @

Regra Para CLC de INSS

/* Regra para reversão dos valores de INSS sobre 1/3 de férias MP 927 */
/* Compilação: 01/04/2020 */

/* Definição dos Cursores de Pesquisa */
Definir Alfa CurR146Prv;

/* Definição da Variaveis globais */
Definir Numero vNumEmp;
Definir Numero vTipCol;
Definir Numero vNumCad;
Definir Numero vTipPrv;
Definir Numero vTipVal;
Definir Numero vPerVal;
Definir Numero vValClc;
Definir Data   vPerRef;

/* Inicialização da Varivies Globais */
vNumEmp = R048Ctb.NumEmp;
vTipCol = R048Ctb.TipCol;
vNumCad = R048Ctb.NumCad;
vTipPrv = 1;  @ Defini que é exclusivo para a provisão de férias @
vTipVal = 3;  @ Defini que é exclusivo para o INSS @
vPerVal = 0;
vValClc = R048Ctb.ValLan;
vPerRef = PerRef;

/* Pesquisa o percentual de INSS aplicado no último calculo realizado da provisão */
SQL_Criar(CurR146Prv);
SQL_UsarAbrangencia(CurR146Prv,0); 
SQL_USARSQLSENIOR2(CurR146Prv,0);  
SQL_DefinirComando(CurR146Prv,"Select PerVal From R146Prv B \
                               where B.NumEmp = :vNumEmp \
                                 and B.Tipcol = :vTipCol \
                                 and B.NumCad = :vNumCad \
                                 and B.TipPrv = :vTipPrv \
                                 and B.TipVal = :vTipVal \
                                 and B.MesAno = (Select Max(A.MesAno) From R146Prv A \
                                                 Where B.NumEmp = A.NumEmp \
                                                   and B.TipCol = A.TipCol \
                                                   and B.NumCad = A.NumCad \
                                                   and B.TipPrv = A.TipPrv \
                                                   and B.TipVal = A.TipVal \
                                                   and A.MesAno <= :vPerRef)");
SQL_DefinirInteiro(CurR146Prv,"vNumEmp",vNumEmp);
SQL_DefinirInteiro(CurR146Prv,"vTipCol",vTipCol);
SQL_DefinirInteiro(CurR146Prv,"vNumCad",vNumCad);
SQL_DefinirInteiro(CurR146Prv,"vTipPrv",vTipPrv);
SQL_DefinirInteiro(CurR146Prv,"vTipVal",vTipVal);
SQL_DefinirData(CurR146Prv,"vPerRef",vPerRef);
SQL_AbrirCursor(CurR146Prv);
Enquanto (SQL_EOF(CurR146Prv) = 0)
  Inicio
  SQL_RetornarFlutuante(CurR146Prv, "PerVal", vPerVal);
  SQL_Proximo(CurR146Prv);      
  Fim;
SQL_FecharCursor(CurR146Prv);    
SQL_Destruir(CurR146Prv);

/* Apura o valor a ser atibuido ao CLC */
vValClc = (vValClc * vPerVal) / 100;
ArredondarValor(vValClc, 2); @ Arredonda o valor para duas casas decimais @

R048Ctb.ValLan = vValClc; @ Atribui o valor do lançamento contábil @

Ajustes de valores da reversão do INSS sobre 1/3 de Férias

Quando a coluna dos relatórios de provisão apresentarem divergências, com valores de INSS de reversão de Férias, torna-se necessário realizar o ajuste de valores da reversão sobre 1/3 de Férias.

Veja, abaixo, como deverão ser configurados os CLCs para ajustar os valores, ocasionados pela alteração de percentual em período de vigência da MP 927. Esse procedimento ajustará os valores da contabilização. Para isso, será necessário estabelecer as seguintes configurações:

Criar regra para CLC de ajuste de reversão de INSS:

/* Regra para ajuste da reversão dos valores de INSS sobre 1/3 de férias MP 927 */

/* Definição dos cursores de pesquisa */
Definir Alfa CurR146Prv;
Definir Alfa CurR048Ctb;

/* Definição da variáveis globais */
Definir Numero vNumEmp;
Definir Numero vTipCol;
Definir Numero vNumCad;
Definir Numero vTipPrv;
Definir Numero vTipVal;
Definir Numero vPerVal;
Definir Numero vValClc;
Definir Numero vValBas;
Definir Numero vValPro;
Definir Numero vClcRev;
Definir Numero vClcIns;
Definir Numero vClcAju;
Definir Alfa vConGer;
Definir Data vPerRef;
Definir Data vDatLan;

/* Inicialização da variáveis globais */
vNumEmp = R048Ctb.NumEmp;
vTipCol = R048Ctb.TipCol;
vNumCad = R048Ctb.NumCad;
vTipPrv = 1;   @ Define que é exclusivo para a provisão de férias @
vTipVal = 3;   @ Define que é exclusivo para o INSS @
vPerVal = 0;
vConGer = "0"; @ Define que é exclusivo para registros não gerenciais @
vPerRef = PerRef;

MontaData (24, 03, 2020, vDatLan);

/* O cliente deve informar os códigos dos CLCs criados para reversão e ajuste */
vClcRev = 1; /* Código do CLC de reversão do valor de 1/3 */
vClcIns = 2; /* Código do CLC de reversão do valor de 1/3 sobre INSS*/
vClcAju = 3; /* Código do CLC de ajuste de reversão do valor de 1/3 sobre INSS*/

/* Buscar último lançamento do CLC de ajuste de reversão */
SQL_Criar(CurR048Ctb);
SQL_UsarAbrangencia(CurR048Ctb,0);
SQL_USARSQLSENIOR2(CurR048Ctb,0);
SQL_DefinirComando(CurR048Ctb,"Select MAX(DatLan) DatLan  \
                                 From R048ctb B           \
                                where B.NumEmp = :vNumEmp \
                                  and B.Tipcol = :vTipCol \
                                  and B.NumCad = :vNumCad \
                                  and B.CodClc = :vClcAju \
                                  and B.ConGer = :vConGer \
                                  and B.DatLan < :vPerRef");
SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vNumEmp);
SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vNumCad);
SQL_DefinirInteiro(CurR048Ctb,"vClcAju",vClcAju);
SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
SQL_DefinirData(CurR048Ctb,"vPerRef",vPerRef);
SQL_AbrirCursor(CurR048Ctb);
Se (SQL_EOF(CurR048Ctb) = 0)
SQL_RetornarData(CurR048Ctb, "DatLan", vDatLan);
SQL_FecharCursor(CurR048Ctb);
SQL_Destruir(CurR048Ctb);

/* Buscar o valor do CLC de 1/3 reversão */
SQL_Criar(CurR048Ctb);
SQL_UsarAbrangencia(CurR048Ctb,0);
SQL_USARSQLSENIOR2(CurR048Ctb,0);
SQL_DefinirComando(CurR048Ctb,"Select SUM(ValLan) ValLan  \
                                 From R048ctb B           \
                                where B.NumEmp = :vNumEmp \
                                  and B.Tipcol = :vTipCol \
                                  and B.NumCad = :vNumCad \
                                  and B.CodClc = :vClcRev \
                                  and B.ConGer = :vConGer \
                                  and B.DatLan < :vPerRef \
                                  and B.DatLan > :vDatLan");
SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vNumEmp);
SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vNumCad);
SQL_DefinirInteiro(CurR048Ctb,"vClcRev",vClcRev);
SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
SQL_DefinirData(CurR048Ctb,"vPerRef",vPerRef);
SQL_DefinirData(CurR048Ctb,"vDatLan",vDatLan);
SQL_AbrirCursor(CurR048Ctb);
Se (SQL_EOF(CurR048Ctb) = 0)
SQL_RetornarFlutuante(CurR048Ctb, "ValLan", vValBas);
SQL_FecharCursor(CurR048Ctb);
SQL_Destruir(CurR048Ctb);

/* Buscar o valor do CLC de reversão de 1/3 INSS */
SQL_Criar(CurR048Ctb);
SQL_UsarAbrangencia(CurR048Ctb,0);
SQL_USARSQLSENIOR2(CurR048Ctb,0);
SQL_DefinirComando(CurR048Ctb,"Select SUM(ValLan) ValLan  \
                                 From R048ctb B           \
                                where B.NumEmp = :vNumEmp \
                                  and B.Tipcol = :vTipCol \
                                  and B.NumCad = :vNumCad \
                                  and B.CodClc = :vClcIns \
                                  and B.ConGer = :vConGer \
                                  and B.DatLan < :vPerRef \
                                  and B.DatLan > :vDatLan");
SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vNumEmp);
SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vNumCad);
SQL_DefinirInteiro(CurR048Ctb,"vClcIns",vClcIns);
SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
SQL_DefinirData(CurR048Ctb,"vPerRef",vPerRef);
SQL_DefinirData(CurR048Ctb,"vDatLan",vDatLan);
SQL_AbrirCursor(CurR048Ctb);
Se (SQL_EOF(CurR048Ctb) = 0)
SQL_RetornarFlutuante(CurR048Ctb, "ValLan", vValPro);
SQL_FecharCursor(CurR048Ctb);
SQL_Destruir(CurR048Ctb);

/* Pesquisa o percentual de INSS aplicado no último cálculo realizado da provisão */
SQL_Criar(CurR146Prv);
SQL_UsarAbrangencia(CurR146Prv,0);
SQL_USARSQLSENIOR2(CurR146Prv,0);
SQL_DefinirComando(CurR146Prv,"Select PerVal                                 \
                                 From R146Prv B                              \
                                where B.NumEmp = :vNumEmp                    \
                                  and B.Tipcol = :vTipCol                    \
                                  and B.NumCad = :vNumCad                    \
                                  and B.TipPrv = :vTipPrv                    \
                                  and B.TipVal = :vTipVal                    \
                                  and B.MesAno = (Select Max(A.MesAno)       \
                                                    From R146Prv A           \
                                                   Where B.NumEmp = A.NumEmp \
                                                     and B.TipCol = A.TipCol \
                                                     and B.NumCad = A.NumCad \
                                                     and B.TipPrv = A.TipPrv \
                                                     and B.TipVal = A.TipVal \
                                                     and A.MesAno <= :vPerRef)");
SQL_DefinirInteiro(CurR146Prv,"vNumEmp",vNumEmp);
SQL_DefinirInteiro(CurR146Prv,"vTipCol",vTipCol);
SQL_DefinirInteiro(CurR146Prv,"vNumCad",vNumCad);
SQL_DefinirInteiro(CurR146Prv,"vTipPrv",vTipPrv);
SQL_DefinirInteiro(CurR146Prv,"vTipVal",vTipVal);
SQL_DefinirData(CurR146Prv,"vPerRef",vPerRef);
SQL_AbrirCursor(CurR146Prv);
Enquanto (SQL_EOF(CurR146Prv) = 0)
Inicio
SQL_RetornarFlutuante(CurR146Prv, "PerVal", vPerVal);
SQL_Proximo(CurR146Prv);
Fim;
SQL_FecharCursor(CurR146Prv);
SQL_Destruir(CurR146Prv);

/* Apurar o valor a ser atribuido ao CLC */
vValClc = (vValBas * vPerVal) / 100;
ArredondarValor(vValClc, 2); @ Arredonda o valor para duas casas decimais @

/* Verificar se vai ter Ajuste nos valores provisionados de 1/3 INSS */

/* Definição de variáveis de contabilização. */
Definir Alfa xDebCre;
Definir Alfa xConCre;
Definir Alfa xConDeb;
Definir Alfa xConCrP;
Definir Alfa xConDeP;
Definir Numero xValLan;
Definir Numero xRedCre;
Definir Numero xRedDeb;
Definir Numero xRedCrP;
Definir Numero xRedDeP;

xValLan = vValClc - vValPro;

/* Se o valor do lançamento for negativo. */
Se (xValLan < 0)
Inicio
/* Tornar o valor positivo. */
xValLan = xValLan * -1;

/* Inverter o tipo da conta. */
Se (R048Ctb.DebCre = "C")
Inicio
xDebCre = "D";
Fim;
Senao
Inicio
xDebCre = "C";
Fim;

/* Trocar as contas de crédito e débito. */
xConCre = R048Ctb.ConDeb;
xConDeb = R048Ctb.ConCre;
xConCrP = R048Ctb.ConDeP;
xConDeP = R048Ctb.ConCrP;
xRedCre = R048Ctb.RedDeb;
xRedDeb = R048Ctb.RedCre;
xRedCrP = R048Ctb.RedDeP;
xRedDeP = R048Ctb.RedCrP;

/* Atribuir os valores da contabilização. */
R048Ctb.DebCre = xDebCre;
R048Ctb.ConCre = xConCre;
R048Ctb.ConDeb = xConDeb;
R048Ctb.ConCrP = xConCrP;
R048Ctb.ConDeP = xConDeP;
R048Ctb.RedCre = xRedCre;
R048Ctb.RedDeb = xRedDeb;
R048Ctb.RedCrP = xRedCrP;
R048Ctb.RedDeP = xRedDeP;
Fim;

R048Ctb.ValLan = xValLan; @ Atribuir o valor do lançamento contábil @

Ajustar as informações da regra:

Alterar os campos mencionados no print pelos códigos dos CLCs correspondentes.

vClcRev: informa o código do CLC de reversão do valor de 1/3;
vClcIns: informar o código do CLC de reversão do valor de 1/3 sobre INSS;
vClcAju: informar o código do CLC de ajuste de reversão do valor de 1/3 sobre INSS.

Criar novo(s) CLC(s) e informar a nova regra criada no processo anterior, que receberá o valor do ajuste:

Transferência dos valores de férias MP 927

Para ajustar valores de férias de colaboradores que possuem um saldo de Covid-19 a receber decorrentes da MP 927, mas foram transferidos de empresa e/ou filial antes de sua quitação, explicaremos como deverão ser configurados os CLCs:

Criar dois CLCs (Débito/Crédito) para cada valor vinculado ao Covid-19 que deseja transferir:

Exemplo: 1/3 Férias precisa de dois CLCs (C/D), o INSS outros dois CLCs, o mesmo ocorre para FGTS, PIS e possíveis valores de ajustes da reversão dos encargos.

Um CLC deverá ser Tipo Base igual Regra, onde será vinculada uma nova regra para transferência de saldo:

Outro CLC deverá conter o Nível Lançamento igual a T – Total Empresa e Tipo Base igual a C – CLCs informando o CLC criado anteriormente no campo Bases.

Observação

Para cada saldo "COVID19" a ser transferido será necessário criar 2 CLCs com essas características.

Criar uma regra LSP para cada saldo de Covid-19 a ser contabilizado e vincular ao CLC correspondente, configurado com opção Tipo Base igual R - Regra:

/*--------------------------------------------------------*/
/* Versão: 2                                              */
/* Regra para tranferência de valores para atender MP-927 */
/*--------------------------------------------------------*/

/* Definição dos cursores de pesquisa */
Definir Alfa CurR038Hfi;
Definir Alfa CurR048Ctb;
 
/* Definição das variáveis */
Definir Numero vNumEmp;
Definir Numero vEmpAnt;
Definir Numero vCodFil;
Definir Numero vFilAnt;
Definir Numero vTipCol;
Definir Numero vNumCad;
Definir Numero vCadAnt;
Definir Numero vClcDCV;
Definir Numero vClcQCV;
Definir Numero vClcTCr;
Definir Numero vClcTDe;
Definir Alfa   vConGer;
Definir Alfa   vConCtC;
Definir Alfa   vConCtD;
Definir Data   vDatLan;
Definir Data   vPerRef;
Definir Data   vIniPer;
Definir Data   vFimPer;
 
/* Inicialização das variáveis */
vNumEmp = R048Ctb.NumEmp;
vCodFil = R048Ctb.CodFil;
vTipCol = R048Ctb.TipCol;
vNumCad = R048Ctb.NumCad;
vConGer = R048Ctb.ConGer;
vEmpAnt = 0;
vFilAnt = 0;
vCadAnt = 0;
MontaData (22, 03, 2020, vDatLan);
vPerRef = PerRef;

/* O cliente deve informar os códigos dos CLCs criados para atender MP-927 */
vIniPer = IniCmp; @--- Início do período de transferências       ---@ 
vFimPer = FimCmp; @--- Fim do período de transferências          ---@
vClcDCV = nnnn;   @--- CLC desconto                              ---@
vClcQCV = nnnn;   @--- CLC quitação                              ---@
vClcTCr = nnnn;   @--- CLC transferência "COVID" - 1º CLC        ---@
vClcTDe = nnnn;   @--- CLC transferência "COVID" - 2º CLC        ---@
vConCtC = "aaaa"; @--- Conta Contábil - 1º CLC de transferência  ---@
vConCtD = "aaaa"; @--- Conta Contábil - 2º CLC de transferência  ---@

/*------------------ TRANSFERÊNCIA FILIAIS COM MESMO NUMCAD ------------------*/
Se(vCadAnt = 0)
Inicio
  /* Retorna registros do colaborador com transferência de filial */
  SQL_Criar(CurR038Hfi);
  SQL_UsarAbrangencia(CurR038Hfi,0); 
  SQL_USARSQLSENIOR2(CurR038Hfi,0);  
  SQL_DefinirComando(CurR038Hfi,"SELECT H.NUMEMP NUMEMP,                    \
                                        H.CODFIL CODFIL,                    \
                                        H.NUMCAD NUMCAD                     \
                                   FROM R038HFI H                           \
                                  WHERE H.NUMEMP = :vNumEmp                 \
                                    AND H.EMPATU = :vNumEmp                 \ 
                                    AND H.TIPCOL = :vTipCol                 \
                                    AND H.NUMCAD = :vNumCad                 \
                                    AND H.CADATU = :vCadAtu                 \
                                    AND H.CODFIL <> :vCodFil                \
                                    AND EXISTS (SELECT *                    \
				                                          FROM R038HFI F            \
                                        			   WHERE F.NUMEMP = H.NUMEMP  \
                                        				   AND F.EMPATU = H.EMPATU  \
                                        				   AND F.TIPCOL = H.TIPCOL  \
                                        				   AND F.NUMCAD = H.NUMCAD  \
                                        				   AND F.CADATU = H.CADATU  \
                                        				   AND F.DATALT >= :vIniPer \
                                        				   AND F.DATALT <= :vFimPer)");
  SQL_DefinirInteiro(CurR038Hfi,"vNumEmp",vNumEmp);
  SQL_DefinirInteiro(CurR038Hfi,"vTipCol",vTipCol);
  SQL_DefinirInteiro(CurR038Hfi,"vNumCad",vNumCad);
  SQL_DefinirInteiro(CurR038Hfi,"vCadAtu",vNumCad);
  SQL_DefinirInteiro(CurR038Hfi,"vCodFil",vCodFil);
  SQL_DefinirData(CurR038Hfi,"vIniPer",vIniPer);
  SQL_DefinirData(CurR038Hfi,"vFimPer",vFimPer);
  SQL_AbrirCursor(CurR038Hfi);
  Se (SQL_EOF(CurR038Hfi) = 0)
  Inicio
    SQL_RetornarInteiro(CurR038Hfi,"NUMEMP",vEmpAnt);
    SQL_RetornarInteiro(CurR038Hfi,"CODFIL",vFilAnt);
    SQL_RetornarInteiro(CurR038Hfi,"NUMCAD",vCadAnt);
  Fim;  
  SQL_FecharCursor(CurR038Hfi);    
  SQL_Destruir(CurR038Hfi);
Fim;

/*------------------ TRANSFERÊNCIA FILIAIS COM TROCA NUMCAD ------------------*/
Se(vCadAnt = 0)
Inicio
  /* Retorna registros do colaborador com transferência de filial */
  SQL_Criar(CurR038Hfi);
  SQL_UsarAbrangencia(CurR038Hfi,0); 
  SQL_USARSQLSENIOR2(CurR038Hfi,0);  
  SQL_DefinirComando(CurR038Hfi,"SELECT H.NUMEMP NUMEMP,     \
                                        H.NUMCAD NUMCAD      \                                      
                                   FROM R038HFI H            \ 
                                  WHERE H.NUMEMP = :vNumEmp  \
                                    AND H.EMPATU = :vNumEmp  \
                                    AND H.TIPCOL = :vTipCol  \ 
                                    AND H.CADATU = :vCadAtu  \ 
                                    AND H.NUMCAD <> :vNumCad \
                                    AND H.DATALT >= :vIniPer \
                                    AND H.DATALT <= :vFimPer");
  SQL_DefinirInteiro(CurR038Hfi,"vNumEmp",vNumEmp);
  SQL_DefinirInteiro(CurR038Hfi,"vTipCol",vTipCol);
  SQL_DefinirInteiro(CurR038Hfi,"vCadAtu",vNumCad);
  SQL_DefinirInteiro(CurR038Hfi,"vNumCad",vNumCad);
  SQL_DefinirData(CurR038Hfi,"vIniPer",vIniPer);
  SQL_DefinirData(CurR038Hfi,"vFimPer",vFimPer);
  SQL_AbrirCursor(CurR038Hfi);
  Se (SQL_EOF(CurR038Hfi) = 0)
  Inicio
    SQL_RetornarInteiro(CurR038Hfi,"NUMEMP",vEmpAnt);
    SQL_RetornarInteiro(CurR038Hfi,"NUMCAD",vCadAnt);
  Fim;
  SQL_FecharCursor(CurR038Hfi);    
  SQL_Destruir(CurR038Hfi);

  Se(vCadAnt <> 0)
  Inicio  
    /* Retorna à Filial anterior à transferência */
    SQL_Criar(CurR038Hfi);
    SQL_UsarAbrangencia(CurR038Hfi,0); 
    SQL_USARSQLSENIOR2(CurR038Hfi,0);  
    SQL_DefinirComando(CurR038Hfi,"SELECT H.CODFIL CODFIL     \
                                     FROM R038HFI H           \ 
                                    WHERE H.NUMEMP = :vNumEmp \
                                      AND H.EMPATU = :vNumEmp \
                                      AND H.TIPCOL = :vTipCol \ 
                                      AND H.NUMCAD = :vNumCad \
                                      AND H.CADATU = :vNumCad");
    SQL_DefinirInteiro(CurR038Hfi,"vNumEmp",vEmpAnt);
    SQL_DefinirInteiro(CurR038Hfi,"vTipCol",vTipCol);
    SQL_DefinirInteiro(CurR038Hfi,"vNumCad",vCadAnt);
    SQL_AbrirCursor(CurR038Hfi);
    Se (SQL_EOF(CurR038Hfi) = 0)
    Inicio
      SQL_RetornarInteiro(CurR038Hfi,"CODFIL",vFilAnt);
    Fim;
    SQL_FecharCursor(CurR038Hfi);    
    SQL_Destruir(CurR038Hfi);
  Fim;
Fim;

/*------------------ TRANSFERÊNCIA EMPRESA COM MESMO NUMCAD ------------------*/
Se(vCadAnt = 0)
Inicio
  /* Retorna registros do colaborador com transferência de empresa */
  SQL_Criar(CurR038Hfi);
  SQL_UsarAbrangencia(CurR038Hfi,0); 
  SQL_USARSQLSENIOR2(CurR038Hfi,0);  
  SQL_DefinirComando(CurR038Hfi,"SELECT H.NUMEMP NUMEMP,     \ 
                                        H.CODFIL CODFIL,     \
                                        H.NUMCAD NUMCAD      \
                                   FROM R038HFI H            \ 
                                  WHERE H.EMPATU = :vNumEmp  \
                                    AND H.TIPCOL = :vTipCol  \ 
                                    AND H.NUMCAD = :vNumCad  \
                                    AND H.CADATU = :vCadAtu  \
                                    AND H.NUMEMP <> :vNumEmp \
                                    AND H.DATALT >= :vIniPer \
                                    AND H.DATALT <= :vFimPer");
  SQL_DefinirInteiro(CurR038Hfi,"vNumEmp",vNumEmp);
  SQL_DefinirInteiro(CurR038Hfi,"vTipCol",vTipCol);
  SQL_DefinirInteiro(CurR038Hfi,"vNumCad",vNumCad);
  SQL_DefinirInteiro(CurR038Hfi,"vCadAtu",vNumCad);
  SQL_DefinirData(CurR038Hfi,"vIniPer",vIniPer);
  SQL_DefinirData(CurR038Hfi,"vFimPer",vFimPer);
  SQL_AbrirCursor(CurR038Hfi);
  Se (SQL_EOF(CurR038Hfi) = 0)
  Inicio
    SQL_RetornarInteiro(CurR038Hfi,"NUMEMP",vEmpAnt);
    SQL_RetornarInteiro(CurR038Hfi,"NUMCAD",vCadAnt);
  Fim;
  SQL_FecharCursor(CurR038Hfi);    
  SQL_Destruir(CurR038Hfi);
  
  Se(vCadAnt <> 0)
  Inicio  
    /* Retorna à Filial anterior à transferência */
    SQL_Criar(CurR038Hfi);
    SQL_UsarAbrangencia(CurR038Hfi,0); 
    SQL_USARSQLSENIOR2(CurR038Hfi,0);  
    SQL_DefinirComando(CurR038Hfi,"SELECT H.CODFIL CODFIL     \
                                     FROM R038HFI H           \ 
                                    WHERE H.NUMEMP = :vNumEmp \
                                      AND H.EMPATU = :vNumEmp \
                                      AND H.TIPCOL = :vTipCol \ 
                                      AND H.NUMCAD = :vNumCad \
                                      AND H.CADATU = :vNumCad");
    SQL_DefinirInteiro(CurR038Hfi,"vNumEmp",vEmpAnt);
    SQL_DefinirInteiro(CurR038Hfi,"vTipCol",vTipCol);
    SQL_DefinirInteiro(CurR038Hfi,"vNumCad",vCadAnt);
    SQL_AbrirCursor(CurR038Hfi);
    Se (SQL_EOF(CurR038Hfi) = 0)
    Inicio
      SQL_RetornarInteiro(CurR038Hfi,"CODFIL",vFilAnt);
    Fim;
    SQL_FecharCursor(CurR038Hfi);    
    SQL_Destruir(CurR038Hfi);
  Fim;
Fim;

/*------------------ TRANSFERÊNCIA EMPRESA COM TROCA NUMCAD ------------------*/
Se(vCadAnt = 0)
Inicio
  /* Retorna registros do colaborador com transferência de empresa */
  SQL_Criar(CurR038Hfi);
  SQL_UsarAbrangencia(CurR038Hfi,0); 
  SQL_USARSQLSENIOR2(CurR038Hfi,0);  
  SQL_DefinirComando(CurR038Hfi,"SELECT H.NUMEMP NUMEMP,     \ 
                                        H.CODFIL CODFIL,     \
                                        H.NUMCAD NUMCAD      \                                      
                                   FROM R038HFI H            \ 
                                  WHERE H.EMPATU = :vNumEmp  \
                                    AND H.TIPCOL = :vTipCol  \ 
                                    AND H.CADATU = :vCadAtu  \
                                    AND H.NUMEMP <> :vNumEmp \
                                    AND H.NUMCAD <> :vNumCad \
                                    AND H.DATALT >= :vIniPer \
                                    AND H.DATALT <= :vFimPer");
  SQL_DefinirInteiro(CurR038Hfi,"vNumEmp",vNumEmp);
  SQL_DefinirInteiro(CurR038Hfi,"vTipCol",vTipCol);
  SQL_DefinirInteiro(CurR038Hfi,"vCadAtu",vNumCad);
  SQL_DefinirInteiro(CurR038Hfi,"vNumCad",vNumCad);
  SQL_DefinirData(CurR038Hfi,"vIniPer",vIniPer);
  SQL_DefinirData(CurR038Hfi,"vFimPer",vFimPer);
  SQL_AbrirCursor(CurR038Hfi);
  Se (SQL_EOF(CurR038Hfi) = 0)
  Inicio
    SQL_RetornarInteiro(CurR038Hfi,"NUMEMP",vEmpAnt);
    SQL_RetornarInteiro(CurR038Hfi,"NUMCAD",vCadAnt);
  Fim;
  SQL_FecharCursor(CurR038Hfi);    
  SQL_Destruir(CurR038Hfi);

  Se(vCadAnt <> 0)
  Inicio  
    /* Retorna à Filial anterior à transferência */
    SQL_Criar(CurR038Hfi);
    SQL_UsarAbrangencia(CurR038Hfi,0); 
    SQL_USARSQLSENIOR2(CurR038Hfi,0);  
    SQL_DefinirComando(CurR038Hfi,"SELECT H.CODFIL CODFIL     \
                                     FROM R038HFI H           \ 
                                    WHERE H.NUMEMP = :vNumEmp \
                                      AND H.EMPATU = :vNumEmp \
                                      AND H.TIPCOL = :vTipCol \ 
                                      AND H.NUMCAD = :vNumCad \
                                      AND H.CADATU = :vNumCad");
    SQL_DefinirInteiro(CurR038Hfi,"vNumEmp",vEmpAnt);
    SQL_DefinirInteiro(CurR038Hfi,"vTipCol",vTipCol);
    SQL_DefinirInteiro(CurR038Hfi,"vNumCad",vCadAnt);
    SQL_AbrirCursor(CurR038Hfi);
    Se (SQL_EOF(CurR038Hfi) = 0)
    Inicio
      SQL_RetornarInteiro(CurR038Hfi,"CODFIL",vFilAnt);
    Fim;
    SQL_FecharCursor(CurR038Hfi);    
    SQL_Destruir(CurR038Hfi);
  Fim;
Fim;

/*---------------- CONSISTÊNCIA DE DADOS PARA CONTABILIZAÇÃO -----------------*/
Se(vCadAnt <> 0)
Inicio
  Definir Numero xValDCV;
  Definir Numero xValQCV;
  Definir Numero xValLan;
  Definir Alfa   xExiste;
  Definir Data   xDatLan;

  xValDCV = 0;
  xValQCV = 0;
  xValLan = 0;
  xExiste = "N";  
  xDatLan = R048Ctb.DatLan;

  /* Verifica se CLC de transferência existe na base de dados */
  SQL_Criar(CurR048Ctb);
  SQL_UsarAbrangencia(CurR048Ctb,0); 
  SQL_USARSQLSENIOR2(CurR048Ctb,0);  
  SQL_DefinirComando(CurR048Ctb,"SELECT * FROM R048CTB C           \
                                         WHERE C.NUMEMP = :vNumEmp \
                                           AND C.CODFIL = :vCodFil \
                                           AND C.TIPCOL = :vTipCol \
                                           AND C.NUMCAD = :vNumCad \
                                           AND C.CODCLC = :vCodClc \
                                           AND C.CONGER = :vConGer \
                                           AND C.DATLAN = :vDatLan");
  SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vEmpAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vCodFil",vFilAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
  SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vCadAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vCodClc",vClcTCr);
  SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
  SQL_DefinirData(CurR048Ctb,"vDatLan",xDatLan);
  SQL_AbrirCursor(CurR048Ctb);
  Se(SQL_EOF(CurR048Ctb) = 0)
  Inicio
    xExiste = "S";
  Fim;
  SQL_FecharCursor(CurR048Ctb);    
  SQL_Destruir(CurR048Ctb);

  /* Exclui o registro do CLC Crédito de transferência, caso exista */
  Se (xExiste = "S")
  Inicio
    SQL_Criar(CurR048Ctb);
    SQL_UsarAbrangencia(CurR048Ctb,0); 
    SQL_USARSQLSENIOR2(CurR048Ctb,0);  
    SQL_DefinirComando(CurR048Ctb,"DELETE FROM R048CTB      \
                                    WHERE NUMEMP = :vNumEmp \
                                      AND CODFIL = :vCodFil \
                                      AND TIPCOL = :vTipCol \
                                      AND NUMCAD = :vNumCad \
                                      AND CODCLC = :vCodClc \
                                      AND CONGER = :vConGer \
                                      AND DATLAN = :vDatLan");
    SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vEmpAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vCodFil",vFilAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
    SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vCadAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vCodClc",vClcTCr);
    SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
    SQL_DefinirData(CurR048Ctb,"vDatLan",xDatLan);
    SQL_AbrirCursor(CurR048Ctb);
    SQL_FecharCursor(CurR048Ctb);    
    SQL_Destruir(CurR048Ctb);
  Fim;

  xExiste = "N";

  /* Verifica se CLC de transferência existe na base de dados */
  SQL_Criar(CurR048Ctb);
  SQL_UsarAbrangencia(CurR048Ctb,0); 
  SQL_USARSQLSENIOR2(CurR048Ctb,0);  
  SQL_DefinirComando(CurR048Ctb,"SELECT * FROM R048CTB C           \
                                         WHERE C.NUMEMP = :vNumEmp \
                                           AND C.CODFIL = :vCodFil \
                                           AND C.TIPCOL = :vTipCol \
                                           AND C.NUMCAD = :vNumCad \
                                           AND C.CODCLC = :vCodClc \
                                           AND C.CONGER = :vConGer \
                                           AND C.DATLAN = :vDatLan");
  SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vEmpAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vCodFil",vFilAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
  SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vCadAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vCodClc",vClcTDe);
  SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
  SQL_DefinirData(CurR048Ctb,"vDatLan",xDatLan);
  SQL_AbrirCursor(CurR048Ctb);
  Se(SQL_EOF(CurR048Ctb) = 0)
  Inicio
    xExiste = "S";
  Fim;
  SQL_FecharCursor(CurR048Ctb);    
  SQL_Destruir(CurR048Ctb);

  /* Exclui o registro do CLC Débito de transferência, caso exista */ 
  Se (xExiste = "S")
  Inicio
    SQL_Criar(CurR048Ctb);
    SQL_UsarAbrangencia(CurR048Ctb,0); 
    SQL_USARSQLSENIOR2(CurR048Ctb,0);  
    SQL_DefinirComando(CurR048Ctb,"DELETE FROM R048CTB      \
                                    WHERE NUMEMP = :vNumEmp \
                                      AND CODFIL = :vCodFil \
                                      AND TIPCOL = :vTipCol \
                                      AND NUMCAD = :vNumCad \
                                      AND CODCLC = :vCodClc \
                                      AND CONGER = :vConGer \
                                      AND DATLAN = :vDatLan");
    SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vEmpAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vCodFil",vFilAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
    SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vCadAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vCodClc",vClcTDe);
    SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
    SQL_DefinirData(CurR048Ctb,"vDatLan",xDatLan);
    SQL_AbrirCursor(CurR048Ctb);
    SQL_FecharCursor(CurR048Ctb);    
    SQL_Destruir(CurR048Ctb);
  Fim;  

  /* Retorna valor(es) do CLC Desconto para atender MP-927 */
  SQL_Criar(CurR048Ctb);
  SQL_UsarAbrangencia(CurR048Ctb,0); 
  SQL_USARSQLSENIOR2(CurR048Ctb,0);  
  SQL_DefinirComando(CurR048Ctb,"SELECT SUM(C.VALLAN) VALLAN                    \
                                   FROM R048CTB C                               \
                                  WHERE C.NUMEMP = :vNumEmp                     \
                                    AND C.TIPCOL = :vTipCol                     \
                                    AND C.NUMCAD = :vNumCad                     \
                                    AND C.CODCLC = :vClcDCV                     \
                                    AND C.CONGER = :vConGer                     \
                                    AND C.DATLAN < :vPerRef                     \
                                    AND C.DATLAN > :vDatLan                     \
                                    AND NOT EXISTS (SELECT B.CODCLC CODCLC      \
                                                      FROM R048CTB B            \
                                                     WHERE B.NUMEMP = C.NUMEMP  \
                                                       AND B.TIPCOL = C.TIPCOL  \
                                                       AND B.NUMCAD = C.NUMCAD  \
                                                       AND B.CODCLC = :vClcTCr  \
                                                       AND B.CONGER = C.CONGER  \
                                                       AND B.DATLAN >= :vIniPer \
                                                       AND B.DATLAN <= :vFimPer)");
  SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vEmpAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
  SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vCadAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vClcDCV",vClcDCV);
  SQL_DefinirInteiro(CurR048Ctb,"vClcTCr",vClcTCr);
  SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
  SQL_DefinirData(CurR048Ctb,"vPerRef",vPerRef);
  SQL_DefinirData(CurR048Ctb,"vDatLan",vDatLan);
  SQL_DefinirData(CurR048Ctb,"vIniPer",vIniPer);
  SQL_DefinirData(CurR048Ctb,"vFimPer",vFimPer);
  SQL_AbrirCursor(CurR048Ctb);
  Se (SQL_EOF(CurR048Ctb) = 0)
  Inicio
    SQL_RetornarFlutuante(CurR048Ctb, "ValLan", xValDCV);
  Fim;
  SQL_FecharCursor(CurR048Ctb);    
  SQL_Destruir(CurR048Ctb);

  /* Retorna valor(es) do CLC Quitação para atender MP-927 */
  SQL_Criar(CurR048Ctb);
  SQL_UsarAbrangencia(CurR048Ctb,0); 
  SQL_USARSQLSENIOR2(CurR048Ctb,0);  
  SQL_DefinirComando(CurR048Ctb,"SELECT SUM(C.VALLAN) VALLAN                    \
                                   FROM R048CTB C                               \
                                  WHERE C.NUMEMP = :vNumEmp                     \
                                    AND C.TIPCOL = :vTipCol                     \
                                    AND C.NUMCAD = :vNumCad                     \
                                    AND C.CODCLC = :vClcQCV                     \
                                    AND C.CONGER = :vConGer                     \
                                    AND C.DATLAN < :vPerRef                     \
                                    AND C.DATLAN > :vDatLan                     \
                                    AND NOT EXISTS (SELECT B.CODCLC CODCLC      \
                                                      FROM R048CTB B            \
                                                     WHERE B.NUMEMP = C.NUMEMP  \
                                                       AND B.TIPCOL = C.TIPCOL  \
                                                       AND B.NUMCAD = C.NUMCAD  \
                                                       AND B.CODCLC = :vClcTDe  \
                                                       AND B.CONGER = C.CONGER  \
                                                       AND B.DATLAN >= :vIniPer \
                                                       AND B.DATLAN <= :vFimPer)");
  SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vEmpAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
  SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vCadAnt);
  SQL_DefinirInteiro(CurR048Ctb,"vClcQCV",vClcQCV);
  SQL_DefinirInteiro(CurR048Ctb,"vClcTDe",vClcTDe);
  SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
  SQL_DefinirData(CurR048Ctb,"vPerRef",vPerRef);
  SQL_DefinirData(CurR048Ctb,"vDatLan",vDatLan);
  SQL_DefinirData(CurR048Ctb,"vIniPer",vIniPer);
  SQL_DefinirData(CurR048Ctb,"vFimPer",vFimPer);
  SQL_AbrirCursor(CurR048Ctb);
  Se (SQL_EOF(CurR048Ctb) = 0)
  Inicio
    SQL_RetornarFlutuante(CurR048Ctb, "VALLAN", xValQCV);
  Fim;
  SQL_FecharCursor(CurR048Ctb);    
  SQL_Destruir(CurR048Ctb);

  /* Atribui o valor do lançamento do CLC de transferência */
  xValLan = xValDCV - xValQCV;

  /*---------------- Ajustes de dados a serem contabilizados -----------------*/
  Se(xValLan <> 0) 
  Inicio
    Definir Numero tNumEmp;
    Definir Numero tTipCol;
    Definir Numero tNumCad;
    Definir Numero tCodFil;
    Definir Numero tCodOem;
    Definir Numero tSeqPag;
    Definir Numero tTabOrg;
    Definir Numero tTabEve;
    Definir Numero tCodClc;
    Definir Data   tDatLan;
    Definir Numero tOpcCtb;
    Definir Numero tCodCal;
    Definir Numero tCodLot;
    Definir Numero tSeqLot;
    Definir Alfa   tDebCre;
    Definir Numero tHisPad;
    Definir Alfa   tCplHis;
    Definir Numero tNatDes;
    Definir Numero tConFin;
    Definir Numero tCodAux;
    Definir Alfa   tConGer;
    Definir Numero tPerRat;
    Definir Numero tCodFor;
    Definir Numero tClcPdb;
    Definir Alfa   tNumDoc;
    Definir Alfa   tNomCon;
    Definir Alfa   tOriCtb;
    Definir Numero tLotSap;
    Definir Numero tValLan;
    Definir Numero tFilCtb;
    Definir Alfa   tCcuRat;
    Definir Numero tLocRat;
    Definir Numero tCodRat;
    Definir Alfa   tConDeb;
    Definir Alfa   tConCre;
    Definir Numero tRedDeb;
    Definir Numero tRedCre;
    Definir Numero tFilCtp;
    Definir Alfa   tCodCcu;
    Definir Numero tNumLoc;
    Definir Numero tRatPad;
    Definir Alfa   tConDep;
    Definir Alfa   tConCrp;
    Definir Numero tRedDep;
    Definir Numero tRedCrp;
    Definir Numero tDefCon;
      
    SQL_Criar(CurR048Ctb);
    SQL_UsarAbrangencia(CurR048Ctb,0); 
    SQL_USARSQLSENIOR2(CurR048Ctb,0);  
    SQL_DefinirComando(CurR048Ctb, "SELECT C.NUMEMP,                              \
                                      	   C.TIPCOL,                              \
                                      	   C.NUMCAD,                              \
                                      	   C.CODFIL,                              \
                                      	   C.CODOEM,                              \
                                      	   C.SEQPAG,                              \
                                      	   C.TABORG,                              \
                                      	   C.TABEVE,                              \
                                      	   C.CODCLC,                              \
                                      	   C.DATLAN,                              \
                                      	   C.OPCCTB,                              \
                                      	   C.CODCAL,                              \
                                      	   C.CODLOT,                              \
                                      	   C.SEQLOT,                              \
                                      	   C.DEBCRE,                              \
                                      	   C.HISPAD,                              \
                                      	   C.CPLHIS,                              \
                                      	   C.NATDES,                              \
                                      	   C.CONFIN,                              \
                                      	   C.CODAUX,                              \
                                      	   C.CONGER,                              \
                                      	   C.PERRAT,                              \
                                      	   C.CODFOR,                              \
                                      	   C.CLCPDB,                              \
                                      	   C.NUMDOC,                              \
                                      	   C.NOMCON,                              \
                                      	   C.ORICTB,                              \
                                      	   C.LOTSAP,                              \
                                      	   C.VALLAN,                              \
                                      	   C.FILCTB,                              \
                                      	   C.CCURAT,                              \
                                      	   C.LOCRAT,                              \
                                      	   C.CODRAT,                              \
                                      	   C.CONDEB,                              \
                                      	   C.CONCRE,                              \
                                      	   C.REDDEB,                              \
                                      	   C.REDCRE,                              \
                                      	   C.FILCTP,                              \
                                      	   C.CODCCU,                              \
                                      	   C.NUMLOC,                              \
                                      	   C.RATPAD,                              \
                                      	   C.CONDEP,                              \
                                      	   C.CONCRP,                              \
                                      	   C.REDDEP,                              \
                                      	   C.REDCRP,                              \
                                      	   C.DEFCON                               \
                                      FROM R048CTB C                              \
                                     WHERE C.NUMEMP = :vNumEmp                    \
                                       AND C.TIPCOL = :vTipCol                    \
                                       AND C.NUMCAD = :vNumCad                    \
                                       AND C.CODCLC = :vCodClc                    \
                                       AND C.CONGER = :vConGer                    \
                                       AND C.DATLAN = (SELECT MAX(B.DATLAN)       \
                                              					 FROM R048CTB B           \
                                              					WHERE B.NUMEMP = C.NUMEMP \
                                              					  AND B.TIPCOL = C.TIPCOL \
                                              					  AND B.NUMCAD = C.NUMCAD \
                                                				  AND B.CODCLC = C.CODCLC \
                                              					  AND B.CONGER = C.CONGER \
                                              					  AND B.DATLAN < :vPerRef)");
    SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vEmpAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
    SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vCadAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vCodClc",vClcDCV);
    SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
    SQL_DefinirData(CurR048Ctb,"vPerRef",vPerRef);
    SQL_AbrirCursor(CurR048Ctb);
    Se (SQL_EOF(CurR048Ctb) = 0)
    Inicio
			SQL_RetornarInteiro(CurR048Ctb,"NUMEMP",tNumEmp);
			SQL_RetornarInteiro(CurR048Ctb,"TIPCOL",tTipCol);
			SQL_RetornarInteiro(CurR048Ctb,"NUMCAD",tNumCad);
			SQL_RetornarInteiro(CurR048Ctb,"CODFIL",tCodFil);
			SQL_RetornarInteiro(CurR048Ctb,"CODOEM",tCodOem);
			SQL_RetornarInteiro(CurR048Ctb,"SEQPAG",tSeqPag);
			SQL_RetornarInteiro(CurR048Ctb,"TABORG",tTabOrg);
			SQL_RetornarInteiro(CurR048Ctb,"TABEVE",tTabEve);
			SQL_RetornarInteiro(CurR048Ctb,"CODCLC",tCodClc);
			SQL_RetornarData(CurR048Ctb,"DATLAN",tDatLan);
			SQL_RetornarInteiro(CurR048Ctb,"OPCCTB",tOpcCtb);
			SQL_RetornarInteiro(CurR048Ctb,"CODCAL",tCodCal);
			SQL_RetornarInteiro(CurR048Ctb,"CODLOT",tCodLot);
			SQL_RetornarInteiro(CurR048Ctb,"SEQLOT",tSeqLot);
			SQL_RetornarAlfa(CurR048Ctb,"DEBCRE",tDebCre);
			SQL_RetornarInteiro(CurR048Ctb,"HISPAD",tHisPad);
			SQL_RetornarAlfa(CurR048Ctb,"CPLHIS",tCplHis);
			SQL_RetornarInteiro(CurR048Ctb,"NATDES",tNatDes);
			SQL_RetornarInteiro(CurR048Ctb,"CONFIN",tConFin);
			SQL_RetornarInteiro(CurR048Ctb,"CODAUX",tCodAux);
			SQL_RetornarAlfa(CurR048Ctb,"CONGER",tConGer);
			SQL_RetornarFlutuante(CurR048Ctb,"PERRAT",tPerRat);
			SQL_RetornarInteiro(CurR048Ctb,"CODFOR",tCodFor);
			SQL_RetornarInteiro(CurR048Ctb,"CLCPDB",tClcPdb);
			SQL_RetornarAlfa(CurR048Ctb,"NUMDOC",tNumDoc);
			SQL_RetornarAlfa(CurR048Ctb,"NOMCON",tNomCon);
			SQL_RetornarAlfa(CurR048Ctb,"ORICTB",tOriCtb);
			SQL_RetornarInteiro(CurR048Ctb,"LOTSAP",tLotSap);
			SQL_RetornarFlutuante(CurR048Ctb,"VALLAN",tValLan);
			SQL_RetornarInteiro(CurR048Ctb,"FILCTB",tFilCtb);
			SQL_RetornarAlfa(CurR048Ctb,"CCURAT",tCcuRat);
			SQL_RetornarInteiro(CurR048Ctb,"LOCRAT",tLocRat);
			SQL_RetornarInteiro(CurR048Ctb,"CODRAT",tCodRat);
			SQL_RetornarAlfa(CurR048Ctb,"CONDEB",tConDeb);
			SQL_RetornarAlfa(CurR048Ctb,"CONCRE",tConCre);
			SQL_RetornarInteiro(CurR048Ctb,"REDDEB",tRedDeb);
			SQL_RetornarInteiro(CurR048Ctb,"REDCRE",tRedCre);
			SQL_RetornarInteiro(CurR048Ctb,"FILCTP",tFilCtp);
			SQL_RetornarAlfa(CurR048Ctb,"CODCCU",tCodCcu);
			SQL_RetornarInteiro(CurR048Ctb,"NUMLOC",tNumLoc);
			SQL_RetornarInteiro(CurR048Ctb,"RATPAD",tRatPad);
			SQL_RetornarAlfa(CurR048Ctb,"CONDEP",tConDep);
			SQL_RetornarAlfa(CurR048Ctb,"CONCRP",tConCrp);
			SQL_RetornarInteiro(CurR048Ctb,"REDDEP",tRedDep);
			SQL_RetornarInteiro(CurR048Ctb,"REDCRP",tRedCrp);
			SQL_RetornarInteiro(CurR048Ctb,"DEFCON",tDefCon);
    Fim;
    SQL_FecharCursor(CurR048Ctb);    
    SQL_Destruir(CurR048Ctb);

    /*---------------------- INVERTER CONTAS CONTÁBEIS -----------------------*/
    Definir Alfa xDebCre;
    Definir Alfa xConCre;
    Definir Alfa xConDeb;
    Definir Alfa xConCrP;
    Definir Alfa xConDeP;
    Definir Numero xRedCre;
    Definir Numero xRedDeb;
    Definir Numero xRedCrP;
    Definir Numero xRedDeP;
    Definir Numero xDefCon;

    /* Inverte dados do lançamentos contábeis */  
    Se (xValLan < 0)
    Inicio
      xValLan = xValLan * -1;

      Se(R048Ctb.DebCre = "C")
      Inicio
        xDebCre = "D";
      Fim;
      Senao
      Inicio
        xDebCre = "C";
      Fim;

      /* Trocar as contas de crédito e débito. */  
      xConCre = R048Ctb.ConDeb;
      xConDeb = R048Ctb.ConCre;
      xConCrP = R048Ctb.ConDeP;
      xConDeP = R048Ctb.ConCrP;
      xRedCre = R048Ctb.RedDeb;
      xRedDeb = R048Ctb.RedCre;
      xRedCrP = R048Ctb.RedDeP;
      xRedDeP = R048Ctb.RedCrP;

      /* Atribuir os valores da contabilização. */
      R048Ctb.DebCre = xDebCre;
      R048Ctb.ConCre = xConCre;
      R048Ctb.ConDeb = xConDeb;
      R048Ctb.ConCrP = xConCrP;
      R048Ctb.ConDeP = xConDeP;
      R048Ctb.RedCre = xRedCre;
      R048Ctb.RedDeb = xRedDeb;
      R048Ctb.RedCrP = xRedCrP;
      R048Ctb.RedDeP = xRedDeP;
    Fim;
    R048Ctb.ValLan = xValLan;

    /*---------------------- INSERIR REGISTROS CONTÁBEIS -----------------------*/
    /* Inverte o Tipo Lançamento */
    Se (R048Ctb.DebCre = "C")
    Inicio
      xDebCre = "D";
    Fim;
    Senao
    Inicio
      xDebCre = "C";
    Fim;

    /* Insere dados do CLC de tranferência saída */
    SQL_Criar(CurR048Ctb);
    SQL_UsarAbrangencia(CurR048Ctb,0); 
    SQL_USARSQLSENIOR2(CurR048Ctb,0);  
    SQL_DefinirComando(CurR048Ctb,"INSERT INTO R048CTB (NUMEMP, TIPCOL, NUMCAD, CODFIL, CODOEM, SEQPAG, TABORG, TABEVE, CODCLC,         \
                                                        DATLAN, OPCCTB, CODCAL, CODLOT, SEQLOT, DEBCRE, HISPAD, CPLHIS, NATDES,         \
                                                        CONFIN, CODAUX, CONGER, PERRAT, CODFOR, CLCPDB, NUMDOC, NOMCON, ORICTB,         \
                                                        LOTSAP, VALLAN, FILCTB, CCURAT, LOCRAT, CODRAT, CONDEB, CONCRE, REDDEB,         \
                                                        REDCRE, FILCTP, CODCCU, NUMLOC, RATPAD, CONDEP, CONCRP, REDDEP, REDCRP, DEFCON) \
                                                VALUES (:vNumEmp, :vTipCol, :vNumCad, :vCodFil, :vCodOem, :vSeqPag, :vTabOrg, :vTabEve, \
                                                        :vCodClc, :vDatLan, :vOpcCtb, :vCodCal, :vCodLot, :vSeqLot, :vDebCre, :vHisPad, \
                                                        :vCplHis, :vNatDes, :vConFin, :vCodAux, :vConGer, :vPerRat, :vCodFor, :vClcPdb, \
                                                        :vNumDoc, :vNomCon, :vOriCtb, :vLotSap, :vValLan, :vFilCtb, :vCcuRat, :vLocRat, \
                                                        :vCodRat, :vConDeb, :vConCre, :vRedDeb, :vRedCre, :vFilCtp, :vCodCcu, :vNumLoc, \
                                                        :vRatPad, :vConDep, :vConCrp, :vRedDep, :vRedCrp, :vDefCon)");
    SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vEmpAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
    SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vCadAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vCodFil",vFilAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vCodOem",tCodOem);
    SQL_DefinirInteiro(CurR048Ctb,"vSeqPag",R048Ctb.SeqPag);  
    SQL_DefinirInteiro(CurR048Ctb,"vTabOrg",tTabOrg);
    SQL_DefinirInteiro(CurR048Ctb,"vTabEve",tTabEve);
    SQL_DefinirInteiro(CurR048Ctb,"vCodClc",R048Ctb.CodClc);
    SQL_DefinirData(CurR048Ctb,"vDatLan",R048Ctb.DatLan);
    SQL_DefinirInteiro(CurR048Ctb,"vOpcCtb",R048Ctb.OpcCtb);
    SQL_DefinirInteiro(CurR048Ctb,"vCodCal",R048Ctb.CodCal);
    SQL_DefinirInteiro(CurR048Ctb,"vCodLot",R048Ctb.CodLot);
    SQL_DefinirInteiro(CurR048Ctb,"vSeqLot",R048Ctb.SeqLot);
    SQL_DefinirAlfa(CurR048Ctb,"vDebCre",xDebCre);
    SQL_DefinirInteiro(CurR048Ctb,"vHisPad",R048Ctb.HisPad);
    SQL_DefinirAlfa(CurR048Ctb,"vCplHis",R048Ctb.CplHis);
    SQL_DefinirInteiro(CurR048Ctb,"vNatDes",R048Ctb.NatDes);
    SQL_DefinirInteiro(CurR048Ctb,"vConFin",tConFin);
    SQL_DefinirInteiro(CurR048Ctb,"vCodAux",tCodAux);
    SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
    SQL_DefinirFlutuante(CurR048Ctb,"vPerRat",tPerRat);
    SQL_DefinirInteiro(CurR048Ctb,"vCodFor",tCodFor);
    SQL_DefinirInteiro(CurR048Ctb,"vClcPdb",R048Ctb.ClcPDb);
    SQL_DefinirAlfa(CurR048Ctb,"vNumDoc",R048Ctb.NumDoc);
    SQL_DefinirAlfa(CurR048Ctb,"vNomCon",R048Ctb.NomCon);
    SQL_DefinirAlfa(CurR048Ctb,"vOriCtb",R048Ctb.OriCtb);
    SQL_DefinirInteiro(CurR048Ctb,"vLotSap",R048Ctb.LotSAP);
    SQL_DefinirFlutuante(CurR048Ctb,"vValLan",R048Ctb.ValLan);
    SQL_DefinirInteiro(CurR048Ctb,"vFilCtb",vFilAnt);
    SQL_DefinirAlfa(CurR048Ctb,"vCcuRat",tCcuRat);
    SQL_DefinirInteiro(CurR048Ctb,"vLocRat",tLocRat);
    SQL_DefinirInteiro(CurR048Ctb,"vCodRat",tCodRat);
    SQL_DefinirAlfa(CurR048Ctb,"vConDeb",R048Ctb.ConCre); 
    SQL_DefinirAlfa(CurR048Ctb,"vConCre",R048Ctb.ConDeb); 
    SQL_DefinirInteiro(CurR048Ctb,"vRedDeb",R048Ctb.RedCre);
    SQL_DefinirInteiro(CurR048Ctb,"vRedCre",R048Ctb.RedDeb);    
    SQL_DefinirInteiro(CurR048Ctb,"vFilCtP",vFilAnt);
    SQL_DefinirAlfa(CurR048Ctb,"vCodCcu",tCodCcu);
    SQL_DefinirInteiro(CurR048Ctb,"vNumLoc",tNumLoc);
    SQL_DefinirInteiro(CurR048Ctb,"vRatPad",tRatPad);
    SQL_DefinirAlfa(CurR048Ctb,"vConDeP",R048Ctb.ConCrP);
    SQL_DefinirAlfa(CurR048Ctb,"vConCrP",R048Ctb.ConDeP);
    SQL_DefinirInteiro(CurR048Ctb,"vRedDeP",R048Ctb.RedCrP);
    SQL_DefinirInteiro(CurR048Ctb,"vRedCrP",R048Ctb.RedDeP);
    SQL_DefinirInteiro(CurR048Ctb,"vDefCon",R048Ctb.DefCon);
    SQL_AbrirCursor(CurR048Ctb);
    SQL_FecharCursor(CurR048Ctb);    
    SQL_Destruir(CurR048Ctb);

    /* Alterar Contas Contábeis */
    Se (R048Ctb.DebCre = "C")
    Inicio
      xDebCre = "C";
      xConCre = vConCtD;
      xConDeb = R048Ctb.ConDeb;
      xConCrP = vConCtD;
      xConDeP = R048Ctb.ConDeP;
      xRedCre = R048Ctb.RedCre;
      xRedDeb = R048Ctb.RedDeb;
      xRedCrP = R048Ctb.RedCrP;
      xRedDeP = R048Ctb.RedDeP;
      xDefCon = 6; 
    Fim;
    Senao
    Inicio
      xDebCre = "D";
      xConCre = R048Ctb.ConCre; 
      xConDeb = vConCtD;
      xConCrP = R048Ctb.ConCrP;
      xConDeP = vConCtD;
      xRedCre = R048Ctb.RedCre;
      xRedDeb = R048Ctb.RedDeb;
      xRedCrP = R048Ctb.RedCrP;
      xRedDeP = R048Ctb.RedDeP;
      xDefCon = 6; 
    Fim;

    /* Insere dados CLC de tranferência saída */
    SQL_Criar(CurR048Ctb);
    SQL_UsarAbrangencia(CurR048Ctb,0); 
    SQL_USARSQLSENIOR2(CurR048Ctb,0);  
    SQL_DefinirComando(CurR048Ctb,"INSERT INTO R048CTB (NUMEMP, TIPCOL, NUMCAD, CODFIL, CODOEM, SEQPAG, TABORG, TABEVE, CODCLC,         \
                                                        DATLAN, OPCCTB, CODCAL, CODLOT, SEQLOT, DEBCRE, HISPAD, CPLHIS, NATDES,         \
                                                        CONFIN, CODAUX, CONGER, PERRAT, CODFOR, CLCPDB, NUMDOC, NOMCON, ORICTB,         \ 
                                                        LOTSAP, VALLAN, FILCTB, CCURAT, LOCRAT, CODRAT, CONDEB, CONCRE, REDDEB,         \
                                                        REDCRE, FILCTP, CODCCU, NUMLOC, RATPAD, CONDEP, CONCRP, REDDEP, REDCRP, DEFCON) \
                                                VALUES (:vNumEmp, :vTipCol, :vNumCad, :vCodFil, :vCodOem, :vSeqPag, :vTabOrg, :vTabEve, \
                                                        :vCodClc, :vDatLan, :vOpcCtb, :vCodCal, :vCodLot, :vSeqLot, :vDebCre, :vHisPad, \
                                                        :vCplHis, :vNatDes, :vConFin, :vCodAux, :vConGer, :vPerRat, :vCodFor, :vClcPdb, \
                                                        :vNumDoc, :vNomCon, :vOriCtb, :vLotSap, :vValLan, :vFilCtb, :vCcuRat, :vLocRat, \
                                                        :vCodRat, :vConDeb, :vConCre, :vRedDeb, :vRedCre, :vFilCtp, :vCodCcu, :vNumLoc, \
                                                        :vRatPad, :vConDep, :vConCrp, :vRedDep, :vRedCrp, :vDefCon)");
    SQL_DefinirInteiro(CurR048Ctb,"vNumEmp",vEmpAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vTipCol",vTipCol);
    SQL_DefinirInteiro(CurR048Ctb,"vNumCad",vCadAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vCodFil",vFilAnt);
    SQL_DefinirInteiro(CurR048Ctb,"vCodOem",tCodOem); 
    SQL_DefinirInteiro(CurR048Ctb,"vSeqPag",R048Ctb.SeqPag);
    SQL_DefinirInteiro(CurR048Ctb,"vTabOrg",tTabOrg);
    SQL_DefinirInteiro(CurR048Ctb,"vTabEve",tTabEve);
    SQL_DefinirInteiro(CurR048Ctb,"vCodClc",vClcTDe);
    SQL_DefinirData(CurR048Ctb,"vDatLan",R048Ctb.DatLan);
    SQL_DefinirInteiro(CurR048Ctb,"vOpcCtb",R048Ctb.OpcCtb);
    SQL_DefinirInteiro(CurR048Ctb,"vCodCal",R048Ctb.CodCal);
    SQL_DefinirInteiro(CurR048Ctb,"vCodLot",R048Ctb.CodLot);
    SQL_DefinirInteiro(CurR048Ctb,"vSeqLot",R048Ctb.SeqLot);
    SQL_DefinirAlfa(CurR048Ctb,"vDebCre",xDebCre);
    SQL_DefinirInteiro(CurR048Ctb,"vHisPad",R048Ctb.HisPad);
    SQL_DefinirAlfa(CurR048Ctb,"vCplHis",R048Ctb.CplHis);
    SQL_DefinirInteiro(CurR048Ctb,"vNatDes",R048Ctb.NatDes);
    SQL_DefinirInteiro(CurR048Ctb,"vConFin",tConFin);
    SQL_DefinirInteiro(CurR048Ctb,"vCodAux",tCodAux);
    SQL_DefinirAlfa(CurR048Ctb,"vConGer",vConGer);
    SQL_DefinirFlutuante(CurR048Ctb,"vPerRat",tPerRat);
    SQL_DefinirInteiro(CurR048Ctb,"vCodFor",tCodFor);
    SQL_DefinirInteiro(CurR048Ctb,"vClcPdb",R048Ctb.ClcPdb);
    SQL_DefinirAlfa(CurR048Ctb,"vNumDoc",R048Ctb.NumDoc);
    SQL_DefinirAlfa(CurR048Ctb,"vNomCon",R048Ctb.NomCon);
    SQL_DefinirAlfa(CurR048Ctb,"vOriCtb",R048Ctb.OriCtb);
    SQL_DefinirInteiro(CurR048Ctb,"vLotSap",R048Ctb.LotSap);
    SQL_DefinirFlutuante(CurR048Ctb,"vValLan",R048Ctb.ValLan);
    SQL_DefinirInteiro(CurR048Ctb,"vFilCtb",vFilAnt);
    SQL_DefinirAlfa(CurR048Ctb,"vCcuRat",tCcuRat);
    SQL_DefinirInteiro(CurR048Ctb,"vLocRat",tLocRat);
    SQL_DefinirInteiro(CurR048Ctb,"vCodRat",tCodRat);
    SQL_DefinirAlfa(CurR048Ctb,"vConDeb",xConDeb); 
    SQL_DefinirAlfa(CurR048Ctb,"vConCre",xConCre); 
    SQL_DefinirInteiro(CurR048Ctb,"vRedDeb",xRedDeb);
    SQL_DefinirInteiro(CurR048Ctb,"vRedCre",xRedCre);    
    SQL_DefinirInteiro(CurR048Ctb,"vFilCtp",vFilAnt);
    SQL_DefinirAlfa(CurR048Ctb,"vCodCcu",tCodCcu);
    SQL_DefinirInteiro(CurR048Ctb,"vNumLoc",tNumLoc);
    SQL_DefinirInteiro(CurR048Ctb,"vRatPad",tRatPad);
    SQL_DefinirAlfa(CurR048Ctb,"vConDep",xConDeP);
    SQL_DefinirAlfa(CurR048Ctb,"vConCrp",xConCrP);
    SQL_DefinirInteiro(CurR048Ctb,"vRedDep",xRedDeP);
    SQL_DefinirInteiro(CurR048Ctb,"vRedCrp",xRedCrP);
    SQL_DefinirInteiro(CurR048Ctb,"vDefCon",xDefCon);
    SQL_AbrirCursor(CurR048Ctb);
    SQL_FecharCursor(CurR048Ctb);    
    SQL_Destruir(CurR048Ctb);
  Fim;
Fim;

Ajustar as informações da regra, alterando os campos mencionados a seguir, conforme indicado na imagem:
- vIniPer: data de início do período de transferências. Pode-se utilizar o IniCmp (Data de início da contabilização) ou vDatLan (22/03/2020, data de início da MP 927);
- vFimPer: data de fim do período de transferências. Pode-se utilizar FimCmp (Data de fim contabilização) ou PerRef (1º dia do período de referência da contabilização);
- vClcDCV: CLC desconto correspondente ao saldo que deseja transferir, configurado conforme documentação MP 927;
- vClcQCV: CLC quitação correspondente ao saldo que deseja transferir, configurado conforme documentação MP 927;
- vClcTCr: CLC novo criado para crédito de transferência correspondente ao saldo que deseja transferir;
- vClcTDe: CLC novo criado para débito transferência correspondente ao saldo que deseja transferir;
- vConCtC: código da Conta Contábil configurado com Nível Lançamento igual a C - Centro de Custo ou I - Individual e Tipo Base igual Regra;
- vConCtD: código da Conta Contábil configurado com Nível Lançamento igual T - Total Empresa e Tipo Base igual CLC's, correspondente ao saldo que deseja transferir.

Ajustes para transferências realizadas no período de competência da contabilização:

Ajustes para transferências realizadas desde o início da MP-927:

Observação

Quando realizar a contabilização, serão gerados os CLCs na empresa e/ou filial de origem e destino da transferência do colaborador, para representar saída e entrada de valores transferidos.

Pagamento evento 1/3 de férias Covid-19

Para quitar o evento de 1/3 de férias que não foi pago na data da competência do recibo ou da ficha financeira, deverão ser criados:

Após a vigência da MP 927

O que pode ser feito no Gestão de Pessoas | HCM:

Recibo com adiantamento e pagamento do evento de 1/3 futuro:

O sistema identificava que o recibo calculado era referente à MP 927 através do valor 0,01 informado no campo % Provisão Desconto. Portanto, para assumir o cálculo de recibo de férias padrão, basta não informar o valor 0,01 neste campo.

Novo evento de 1/3 Covid-19:

A regra especial do novo evento de 1/3 Covid-19 precisa ser alterada para considerar a data de vigência da MP 927.

Regra ajustada:

Definir Numero xNumEmp;
Definir Numero xTipCol;
Definir Numero xNumCad;
Definir Numero xCodEve;
Definir Numero xCodTab;
Definir Numero xAchou;
Definir data dIniPer;
Definir data dIniFer;
Definir data dIniCovid;
Definir data dFimCovid;
MontaData (22,03,2020,dIniCovid);
MontaData (19,07,2020,dFimCovid);

@ Calculo refere ao recibo de ferias Normal e Coletiva@
Se ((tipCal >= 51) e (tipCal <= 53))
inicio
  @ Caso não seja referente a MP COVID19 zera o evento@
  Se (((R040FEM.GerAdt = 'S') e (R040FEM.PrvDes <> 0.01)) ou ((R040FEM.GerAdt = 'N') e ((R040FEM.IniFer < dIniCovid) ou (R040FEM.IniFer > dFimCovid))))
    valEvt = 0;
fim
senao
Se (tipCal = 54)@ Integração das ferias com a Folha@
inicio
  xNumEmp = r034fun.NumEmp;
  xTipCol = r034fun.TipCol;
  xNumCad = r034fun.NumCad;
  xCodEve = codEvt;
  dIniPer = r040fem.IniPer;
  dIniFer = r040fem.IniFer;

  @ busca Recibo de ferias Colaborador @
  Definir cursor cur_R040Fem;
  cur_R040Fem.SQL "select PrvDes, IniFer, GerAdt from R040Fem \
                  Where NumEmp = :xNumEmp and TipCol = :xTipCol and NumCad = :xNumCad and IniPer = :dIniPer and IniFer = :dIniFer";
  cur_R040Fem.AbrirCursor();
  Se (cur_R040Fem.Achou)
  inicio
  @ Caso não seja referente a MP COVID19 zera o evento@
  Se (((cur_R040Fem.GerAdt = 'S') e (cur_R040Fem.PrvDes <> 0.01)) ou ((cur_R040Fem.GerAdt = 'N') e ((cur_R040Fem.IniFer < dIniCovid) ou (cur_R040Fem.IniFer > dFimCovid))))
  inicio
    valEvt = 0;
  fim
  senao
  inicio
    @ Se recibo com adiantamtamento e for MP COVID19 @
    Se ((cur_R040Fem.GerAdt = 'S') e (cur_R040Fem.PrvDes = 0.01))
    inicio
      xAchou = 0;
      Definir cursor cur_R030Emp;
      cur_R030Emp.SQL "select CalDpn, TabEve from R030Emp Where NumEmp = :xNumEmp";
      cur_R030Emp.AbrirCursor();
      @Busca assinalmento da empresa pra a rotina de Diferenca Positiva/Negativa de Ferias@
      Se (cur_R030Emp.Achou)
      Inicio
        @Caso utilize a rotina mas não tenha evento configurado trata valor no evento normal de diferença @
        se (cur_R030Emp.CalDpn = 'S')
        inicio
          xCodTab = cur_R030Emp.TabEve;
          Definir cursor cur_R008Evc;
          cur_R008Evc.SQL "select * from R008Evc Where CodTab = :xCodTab and CodEve = :xCodEve and EveDpo > 0";
          cur_R008Evc.AbrirCursor();
          Se (cur_R008Evc.Achou)
          inicio
            xAchou = 1;
          fim
          cur_R008Evc.FecharCursor();
        fim
      fim
      cur_R030Emp.FecharCursor();

      @ Caso não use a rotina de Diferenca Positiva/Negativa ou nao tenha o evento calculado, busca o valor original calculado no recibo de ferias@
      se (xAchou = 0)
      inicio
        Definir cursor cur_R040Fev;
        cur_R040Fev.SQL "select ValEve from R040Fev \
                Where NumEmp = :xNumEmp and TipCol = :xTipCol and NumCad = :xNumCad and IniPer = :dIniPer and IniFer = :dIniFer and CodEve = :xCodEve";
        cur_R040Fev.AbrirCursor();
        Se (cur_R040Fev.Achou)
        inicio
          valEvt = cur_R040Fev.ValEve;
        fim
        cur_R040Fev.FecharCursor();
      fim
    fim
  fim
fim
cur_R040Fem.FecharCursor();
fim
senao
inicio
  valEvt = 0;
fim;

Capítulo IX - DO DIFERIMENTO DO RECOLHIMENTO DO FUNDO DE GARANTIA DO TEMPO DE SERVIÇO

Comunicado Caixa no Conectividade eSocial

Referente ao cálculo do FGTS de competência anterior (março, abril e maio) sem incidência de juros e multas (MP 927):

A CAIXA informa a disponibilidade da tabela de Índices de recolhimento de FGTS em atraso, TF202004, com vigência para o período de 10/04/2020 a 09/05/2020.

Esta tabela foi ajustada para atendimento ao disposto na MP n° 927, de 22 de março de 2020, e permite o cálculo do FGTS referente às competências março e abril de 2020 sem a incidência de juros e multas, mesmo que a geração ocorra após a data limite do dia 07 do mês subsequente.

Ressaltamos que, na geração da Guia Rescisória por meio do Conectividade Social, serviços ao Empregador, (on-line), os cálculos do FGTS referente ao mês anterior à rescisão e o mês atual, quando compreenderem as competências de março, abril e maio de 2020, são geradas, sem a incidência de juros e multas.

Está vetada a geração dos cálculos do FGTS referentes ao mês anterior à rescisão e o mês atual, quando estes compreenderem as competências de março, abril e maio de 2020, por meio do programa GRRF, devendo ser utilizada, obrigatoriamente, a Guia Rescisória por meio do Conectividade Social, serviços ao Empregador, (on-line) ou o programa SEFIP. As demais parcelas ou recolhimentos envolvendo outras competências devem ser tratados, normalmente, por meio do programa GRRF.

Lembramos que os empregadores que quiserem suspender o recolhimento do FGTS das competências de março, abril e maio de 2020, sem a cobrança de multa e encargos, devem declarar as informações dos trabalhadores via SEFIP, utilizando obrigatoriamente a Modalidade 1, até o dia 07 de cada mês.

O empregador que perder o prazo para declaração das competências terá o prazo limite de 20/06/2020 para encaminhar as informações. Após esse prazo, as competências serão consideradas em atraso e terão incidência de multa e encargos devidos na forma do art. 22 da Lei nº 8.036/90.

Perguntas e Respostas

1 - Calculei o recibo de férias e excluí o evento de 1/3 de férias para atender a MP 927, como devo proceder agora com esta solução?

Deverá implementar a solução acima e recalcular o recibo de férias e ficha financeira.

2 - Calculei um recibo de férias com adiantamento de férias e outro sem adiantamento de férias dentro da mesma competência e o sistema não permite o cálculo do segundo recibo, o que devo fazer?

Estamos retirando esta trava na próxima liberação da versão de 27/03/20.

Clientes que estiverem utilizando o HCM na versão 6.2.34.65 (de 14/02/2020) ou superiores e que não tem a possibilidade de realizar a atualização do ambiente agora, podem optar por baixar uma versão alfa, disponível para download aqui: ftp.senior.com.br/downloads/Alfa%20MP-927 (usuário: seniorftp e senha: 3mLfth54s#)

IMPORTANTE:

Nos recibos de férias com adiantamento, enviamos para o eSocial uma rubrica de pagamento do adiantamento com as incidências de IR Férias. E quando gerada a folha de pagamento é enviada uma rubrica sem incidência de IR porque já foi tributado na rubrica de adiantamento.

Nos recibos de férias sem adiantamento, não será enviado para o eSocial a rubrica de pagamento do adiantamento, somente a rubrica do pagamento das férias gerado na folha que estará sem incidência de IR porque é o mesmo evento da situação anterior.

Portanto a base de IR Férias no retorno do S-5002 do eSocial estará menor que a base do IR Férias do Senior. Quanto ao valor de desconto do IR, este estará correto porque o eSocial acata o valor que é informado nos leiautes.

3 - Quero calcular um recibo de férias gerando o pagamento do adiantamento no 5º dia útil do mês subsequente ao início do gozo das férias, como devo proceder?

Deverá informar a data de pagamento na tela de cálculo do recibo. Desta forma o sistema irá calcular os dias de férias e o desconto de adiantamento de férias em cada folha conforme os dias de cada competência. Já o IRRF será gerado conforme a data de pagamento informado no momento da geração.

4 - Conforme o Art. 7º da MP 927, posso suspender as férias dos profissionais da área de saúde ou daqueles que desempenham funções essenciais, como devo proceder no sistema da Senior?

Este processo pode ser atendido pela rotina de Alterar Gozo de Férias já existente.

5 - Como será gerado o evento de 1/3 de Férias para ser pago Futuramente?

Confira as instruções acima.

6 - Ao acessar o Editor de Regras em Recursos / Implementações / Editor de Regras o sistema solicita usuário e senha. Como proceder?

Confira as instruções no nosso Banco de Soluções: 12617 - Solicitação de senha para os artefatos customizados

7 - Como devo proceder com o recolhimento parcelado do FGTS conforme a MP 927?

Veja as orientações da Caixa Econômica sobre suspensão da exigibilidade do FGTS.

A Caixa também disponibilizou uma FAQ sobre os principais temas relacionados à suspensão do recolhimento.

8 - Por que no recibo de férias e na ficha financeira está demonstrando o evento de 1/3 de férias como provento e outro evento de desconto do 1/3 de férias Covid-19 com o mesmo valor?

Porque este valor é devido para aquele recibo de férias e através destes eventos, é o que o sistema efetuará o tratamento para provisão, contabilização e também para o pagamento futuro em rescisão ou folha de pagamento até 20/12/20. Portanto estes eventos não devem ser excluídos.

Notícia relacionada ao(s) produto(s):

Gestão de Pessoas | HCM

Veja mais sobre os outros impactos do Coronavírus na legislação: Histórico de notícias sobre o Coronavírus (COVID-19)