Untitled

User Function REMPBRD(cOP)

// declarações do estoque

Local cEndDest := "BORDA          "
Local cLoc01 := "61"
Local cLoc03 := "73"

// declarações diversas

Local cQuery := ""
Local cSeek := ""

Local nRet := 0
Local nTRT := 0
Local nRegSD4 := 0
Local nRegSDC := 0

Default cOP := ""

If Empty(cOP) // se op vazio abandona a rotina
    Return()
Endif

// verifica a necessidade de processamento da rotina - inicio ***

dbSelectArea("SC2")
SC2->(dbSetOrder(1)) // C2_FILIAL+C2_NUM+C2_ITEM+C2_SEQUEN+C2_ITEMGRD

If SC2->(MsSeek(xFilial("SC2")+cOP))
    If SC2->C2_XPROCES != "S"
        Return(.T.)
    Else
        Reclock("SC2",.F.)
        C2_XPROCES := "N"
        SC2->(MsUnlock())
    Endif
Else
    Return(.F.)
Endif

// verifica a necessidade de processamento da rotina - fim    ***

// verifica se existe trt duplicado o sz4 e acerta a sequencia se houver - inicio ***

cQuery := "SELECT COUNT(Z4_OP), Z4_OP, Z4_PRODUTO, Z4_LOTECTL, Z4_NUMLOTE, Z4_TRT "
cQuery += "FROM " + RetSqlName("SZ4") + " (NOLOCK) "
cQuery += "WHERE D_E_L_E_T_ = ' ' "
cQuery += "AND Z4_FILIAL = '" + xFilial("SZ4") + "' "
cQuery += "AND Z4_OP = '" + AllTrim(cOP) + "' "
cQuery += "GROUP BY Z4_FILIAL, Z4_OP, Z4_PRODUTO, Z4_LOTECTL, Z4_NUMLOTE, Z4_TRT "
cQuery += "HAVING COUNT(Z4_OP) > 1"

MPSysOpenQuery(cQuery, "SQLSZ4")

While SQLSZ4->(!Eof())

    cQuery := "SELECT R_E_C_N_O_ AS Z4_RECNO "
    cQuery := "FROM " + RetSqlName("SZ4") + " (NOLOCK) "
    cQuery := "WHERE D_E_L_E_T_ = ' ' "
    cQuery := "AND Z4_FILIAL = '" + xFilial("SZ4") + "' "
    cQuery := "AND Z4_OP = '" + SQLSZ4->Z4_OP + "' "
    cQuery := "AND Z4_PRODUTO = '" + SQLSZ4->Z4_PRODUTO + "' "
    cQuery := "AND Z4_LOTECTL = '" + SQLSZ4->Z4_LOTECTL + "' "
    cQuery := "AND Z4_NUMLOTE = '" + SQLSZ4->Z4_NUMLOTE + "' "
    cQuery := "AND Z4_TRT = '" + SQLSZ4->Z4_TRT + "' "
    cQuery += "ORDER BY Z4_RECSD4"

    MPSysOpenQuery(cQuery, "SQLTRT")

    nTRT := 115

    While SQLTRT->(!Eof())

        cQuery := "UPDATE " + RetSqlName("SZ4") + " "
        cQuery += "SET Z4_TRT = '" + StrZero(nTRT,3) + "' "
        cQuery += "WHERE R_E_C_N_O_ = " + AllTrim(Str(SQLSZ4->Z4_RECNO))

        nRet := TCSQLExec(cQuery)

        If nRet < 0
            MsgStop("Erro na execução da query:" + TcSqlError(), "AJUSEMP")
        Endif

        nTRT += 1

        SQLTRT->(dbSkip())

    End

    SQLTRT->(dbCloseArea())

    SQLSZ4->(dbSkip())

End

SQLSZ4->(dbCloseArea())

// verifica se existe trt duplicado o sz4 e acerta a sequencia se houver - fim    ***

// trata os estoque e possíveis duplicidades - inicio ***

cQuery := "SELECT * "
cQuery += "FROM " + RetSqlName("SZ4") + " (NOLOCK) "
cQuery += "WHERE D_E_L_E_T_ = ' ' "
cQuery += "AND Z4_FILIAL = '" + xFilial("SZ4") + "' "
cQuery += "AND Z4_OP = '" + AllTrim(cOP) + "'"

MPSysOpenQuery(cQuery, "SQLSDC")

If SQLSDC->(!Eof())

    nRegSD4 := SD4->(RecNo())
    nRegSDC := SDC->(RecNo())

    While SQLSDC->(!Eof())

        // ajusta os estoques

        // *********
        // SB2 *****
        // *********

        nRegSB2 := SB2->(Recno())

        dbSelectArea("SB2")
        SB2->(dbSetOrder(1)) // B2_FILIAL+B2_COD+B2_LOCAL

        If SB2->(MsSeek(xFilial("SB2")+SQLSDC->Z4_PRODUTO))
            While SB2->(!Eof()) .AND. SB2->B2_COD = SQLSDC->Z4_PRODUTO
                If SB2->B2_QATU != SB2->B2_QEMP .AND. (SB2->B2_LOCAL = cLoc01 .OR. SB2->B2_LOCAL = cLoc03)
                    RecLock("SB2",.F.)
                    B2_QEMP := SB2->B2_QATU
                    SB2->(MsUnlock())
                Endif
                SB2->(dbSkip())
            End
        Endif

        SB2->(dbGoto(nRegSB2))

        // *********
        // SB8 *****
        // *********

        nRegSB8 := SB8->(Recno())

        dbSelectArea("SB8")
        SB8->(dbSetOrder(1)) // B8_FILIAL+B8_PRODUTO+B8_LOCAL+DTOS(B8_DTVALID)+B8_LOTECTL+B8_NUMLOTE

        If SB8->(MsSeek(xFilial("SB8")+SQLSDC->Z4_PRODUTO))
            While SB8->(!Eof()) .AND. SB8->B8_PRODUTO = SQLSDC->Z4_PRODUTO
                If SB8->B8_SALDO != SB8->B8_EMPENHO .AND. (SB8->B8_LOCAL = cLoc01 .OR. SB8->B8_LOCAL = cLoc03)
                    RecLock("SB8",.F.)
                    B8_EMPENHO := SB8->B8_SALDO
                    SB8->(MsUnlock())
                Endif
                SB8->(dbSkip())
            End
        Endif

        SB8->(dbGoto(nRegSB8))

        // *********
        // SBF *****
        // *********

        nRegSBF := SBF->(Recno())

        dbSelectArea("SBF")
        SBF->(dbSetOrder(2)) // BF_FILIAL+BF_PRODUTO+BF_LOCAL+BF_LOTECTL+BF_NUMLOTE+BF_PRIOR+BF_LOCALIZ+BF_NUMSERI

        If SBF->(MsSeek(xFilial("SBF")+SQLSDC->Z4_PRODUTO))
            While SBF->(!Eof()) .AND. SBF->BF_PRODUTO = SQLSDC->Z4_PRODUTO
                If SBF->BF_QUANT != SBF->BF_EMPENHO .AND. (SBF->BF_LOCAL = cLoc01 .OR. SBF->BF_LOCAL = cLoc03)
                    RecLock("SBF",.F.)
                    BF_EMPENHO := SBF->BF_QUANT
                    SBF->(MsUnlock())
                Endif
                SBF->(dbSkip())
            End
        Endif

        SBF->(dbGoto(nRegSBF))

        // garante o lote controle

        // *********
        // SD4 *****
        // *********

        SD4->(dbGoTo(SQLSDC->Z4_RECSD4))

        cSeek := xFilial("SDC")+SD4->(D4_COD+D4_LOCAL+D4_OP+D4_TRT+D4_LOTECTL+D4_NUMLOTE) // chave de busca

        If SD4->D4_LOTECTL != SQLSDC->Z4_LOTECTL .AND. (SD4->D4_LOCAL = cLoc01 .OR. SD4->D4_LOCAL = cLoc03) .AND. SD4->D4_QUANT > 0
            Reclock("SD4",.F.) // ajusta as divergências
            D4_LOTECTL := SQLSDC->Z4_LOTECTL
            D4_NUMLOTE := SQLSDC->Z4_NUMLOTE
            D4_TRT     := SQLSDC->Z4_TRT
            SD4->(MsUnlock())
        Endif

        // *********
        // SDC *****
        // *********

        dbSelectArea("SDC") // posiciona
        SDC->(dbSetOrder(2))

        If SDC->(MsSeek(cSeek))
            While SDC->(!Eof()) .AND. SDC->(DC_FILIAL+DC_PRODUTO+DC_LOCAL+DC_OP+DC_TRT+DC_LOTECTL+DC_NUMLOTE) = cSeek
                If SDC->DC_QTDORIG = SD4->D4_QTDEORI .AND. SDC->DC_QUANT > 0 .AND. SDC->DC_LOCALIZ = cEndDest
                    Reclock("SDC",.F.) // ajusta as divergências
                    DC_LOTECTL := SQLSDC->Z4_LOTECTL
                    DC_NUMLOTE := SQLSDC->Z4_NUMLOTE
                    DC_TRT     := SQLSDC->Z4_TRT
                    SDC->(MsUnlock())
                Endif
                SDC->(dbSkip())
            End
        Endif

        SQLSDC->(dbSkip())

    End

    SDC->(dbGoto(nRegSDC))
    SD4->(dbGoto(nRegSD4))

Endif

// trata os estoque e possíveis duplicidades - fim    ***

Return(.T.)