Histórico da Página

#Include 'TOTVS.ch'

/*/{Protheus.doc} User Function MT220GRLA410GRDW
    Permite manipular a alterargrade ode arrayprodutos daem rotinadiversas automáticarotinas do sistema.
 MATA390 - Manutenção deÉ Lotes
possível aplicar tratamento pontual nautilizando inclusãoa defunção saldoFWIsInCallStack
 inicial (MATA220)
  para verificar Pora contarotina daque implementaçãochamou doo ponto de entrada, é recomendado acessar sempre a última posição
    doTambém array,é poispossível overificar pontoqual decampo entradaestá ésendo chamadopreenchido umapelo vezusuário
 por linha da SD5,com ondea é incluida uma linha
    nova a cada chamada.função ReadVar()

    Verificar a documentação completa no TDN
    @type  Function
    @author TOTVS Totvs
    /*/
User Function MT220GRLA410GRDW()
    Local aLotesaHeadAux := ParamIXB[1]
    Local aColsAux := ParamIXB[12]
    Local nLinO aHeader   := ParamIXB[23]
    Local nLast aArea    := GetArea()
    Local aAreaSB4 := SB4->(GetArea())
    Local aAreaSBV := SBV->(GetArea())
    Local aAreaSB1 := SB1->(GetArea())
    Local aAreas   := {aAreaSB4, aAreaSBV, aAreaSB1, aArea}
    Local aCposTel := oGrade:aCposCtrlGrd
    Local cCampo   := StrTran(ReadVar(), 'M->', '')
    Local cMask    := SuperGetMV('MV_MASCGRD', .F., '')
    Local aMask    := Len(aLotes)StrTokArr(cMask, ',')
    Local nTamProd := 0
    Local nTamLin  := 0
    Local nPDtVencnTamCol  := 0
    Local nQtdIni  := 0
    Local nVIni1   := 0
    Local nColGrd  := 0
    Local nLinGrd  := 0
    Local nPQINI   := 0
    Local nPVINI1  := 0
    Local nPQtdnVal     := 0
    Local nPSum nPLote   := 0
    Local cUnMed  nPProd   := 0
    Local cProduto := ''
    Local nNewLast nPQuant  := 0
    Local nQuant   := 0
    Local nPQntC7  := 0
    Local lUsaGrad := .F.
    Local cTabLin  := ''
    Local cTabCol  := ''
    Local aChvLin  := {}
    Local cNewLoteaChvCol  := {}
    Local cChvLin  := ''
    Local aProd    := {}
    Local nProd    := 0

    If Len(aMask) < 3
        Return
    EndIf 
    nTamProd := Val(aMask[1])
    nTamLin  := Val(aMask[2])
    nTamCol  := Val(aMask[3])

    //Alterando somente a última posição do array
Exemplo: Tratamento para o saldo inicial
    If FWIsInCallStack('MATA220')
     //Exemplo: Caso a data de vencimento informada seja igual a data de hoje, alterar para 31/12/2049
    nPDtVenc := AScan(aLotes[nLast]   //Distribui o valor inicial na mesma proporção da quantidade inicial
        If AllTrim(cCampo) == 'B9_VINI1'
            nQtdIni := M->B9_QINI
            nVIni1  := M->B9_VINI1
            nPQINI  := ASCan(aCposTel, {|x| AllTrim(x[1]) == 'B9_QINI'})
            nPVINI1 := ASCan(aCposTel, {|x| AllTrim(x[1]) == 'B9_VINI1'})
            If Len(oGrade:aSumCpos) > 0
                nPSum   := ASCan(oGrade:aSumCpos, {|x| AllTrim(x[1]) == 'D5B9_DTVALIDVINI1'})
            EndIf
            If nPSum > 0
                oGrade:aSumCpos[nPSum, 2] := 0
            EndIf
            If nPDtVenc nQtdIni > 0 .And. nVIni1 > 0 .And. nPQINI > 0 .And. aLotes[nLast, nPDtVenc, 2] <= dDataBase
 nPVINI1 > 0
                For nLinGrd := 1 To Len(aColsGrade[nLinO])
                    For nColGrd := 2 To Len(aColsGrade[nLinO, nLinGrd])
                        nVal := nVINI1 * aColsGrade[nLinO, nLinGrd, nColGrd, nPQINI] / nQtdIni
                        //Manipular o aColsGrade para futura gravação no banco de dados
              aLotes[nLast, nPDtVenc, 2] := CToD('31/12/2049')          aColsGrade[nLinO, nLinGrd, nColGrd, nPVINI1] := nVal
                        //Manipular o aCols para que o usuário visualize os valores pré-carregados
                        aCols[nLinGrd, nColGrd] := nVal
                        //Manipular o totalizador, se houver
                        If nPSum > 0
                            oGrade:aSumCpos[nPSum, 2] += nVal
                        EndIf
                    Next nColGrd
                Next nLinGrd
            EndIf
        EndIf
    EndIf

    //Exemplo: Para produtos controlados em KG, quebra em lotes de 100Kg
    cUnMed := Posicione('SB1', 1, FWXFilial('SB1')+SB9->B9_COD, 'B1_UM')
    nPLote := AScan(aLotes[nLast] Tratamento para o pedido de compras
    If FWIsInCallStack('MATA121') .And. AllTrim(cCampo) == 'C7_QUANT'
        //Distribui o saldo somente na primeira coluna
        nPProd   := ASCan(aHeadAux, {|x| AllTrim(x[2]) == 'C7_PRODUTO'})
        nPQuant  := ASCan(aHeadAux, {|x| AllTrim(x[2]) == 'C7_QUANT'})
        nPQntC7  := ASCan(aCposTel, {|x| AllTrim(x[1]) == 'D5C7_LOTECTLQUANT'})
       nPQtd If Len(oGrade:aSumCpos) > 0
            nPSum   := AScan(aLotes[nLast]ASCan(oGrade:aSumCpos, {|x| AllTrim(x[1]) == 'D5C7_QUANT'})
        EndIf
        If cUnMed == 'KG' nPSum > 0
            oGrade:aSumCpos[nPSum, 2] := 0
        EndIf

        If nPPRod > 0 .And. nPQuant > 0 .And. nPQntC7 > 0
            cProduto := SubStr(aColsAux[nLinO, nPProd], 1, nTamProd) //Código da grade
            nQuant   := M->C7_QUANT //Quantidade digitada no pedido
        EndIf

        If !Empty(cProduto)
            SB4->(DbSetOrder(1)) //B4_FILIAL+B4_COD
            lUsaGrad := SB4->(DbSeek(FWXFilial('SB4')+cProduto))
        EndIf

        If lUsaGrad .And. nPQtdnPQuant > 0
            cTabLin := SB4->B4_LINHA
            cTabCol := SB4->B4_COLUNA

            //Encontra as chaves das tabelas
            SBV->(DbSetOrder(1)) //BV_FILIAL+BV_TABELA+BV_CHAVE
            If SBV->(DbSeek(FWXFilial('SBV')+cTabLin))
                While !SBV->(EoF()) .And. nPLote > 0
 SBV->(BV_FILIAL+BV_TABELA) == FWXFilial('SBV')+cTabLin
                    AAdd(aChvLin, SubStr(SBV->BV_CHAVE, 1, nTamLin))
                    SBV->(DbSkip())
                EndDo
            EndIf
            If SBV->(DbSeek(FWXFilial('SBV')+cTabCol))
               cNewLote := Soma1(RTrim(aLotes[nLast, nPLote, 2]))
 While !SBV->(EoF()) .And. SBV->(BV_FILIAL+BV_TABELA) == FWXFilial('SBV')+cTabCol
                    AAdd(aChvCol, SubStr(SBV->BV_CHAVE, 1, nTamCol))
                    SBV->(DbSkip())
                EndDo
            EndIf

            //Verifica quais produtos foram cadastrados
            SB1->(DbSetOrder(1)) //B1_FILIAL+B1_COD
            aProd := {}
            nColGrd := 1 //Verifica somente a primeira coluna
            For nLinGrd := 1 To Len(aChvLin)
                If SB1->(DbSeek(FWXFilial('SB1')+cProduto+aChvLin[nLinGrd]+aChvCol[nColGrd]))
              While aLotes[nLast, nPQtd, 2] > 100
      AAdd(aProd, {SB1->B1_COD, aChvLin[nLinGrd], aChvCol[nColGrd]})
                EndIf
            Next nLinGrd
            nVal := nQuant / Len(aProd) //Valor distribuido em cada linha da 1a coluna
            //Encontra a posição na grade da primeira coluna. Os campos no aHeader são _+chave da coluna
            nColGrd If:= ASCan(aLotesaHeadGrade[nLinO], {|x| RTrimValType(x)=='A' .And. AllTrim(x[nPLote, 2]) == RTrim(cNewLote)}) '_'+aChvCol[1]})
            If nColGrd > 0
                For cNewLotenLinGrd := Soma1(cNewLote)
1 To Len(aColsGrade[nLinO])
                    //Verifica se o produto existe Loop
para a linha
          EndIf
          cChvLin := aLotesaColsGrade[nLastnLinO, nPQtdnLinGrd, 21] -= 100//<- coluna 1 fixa, contem a chave da linha
            AAdd(aLotes, aClone(aLotes[nLast]))
        cChvLin := SubStr(cChvLin, At('[', cChvLin)+1, nTamLin)
                    nProd nNewLast  := Len(aLotes)
AScan(aProd, {|x| x[2] == cChvLin})
                     aLotes[nNewLast, nPQtd, 2]  := 100If nProd > 0
                        //Manipular o aColsGrade para futura gravação no banco de dados
                        aColsGrade[nLinO, nLinGrd, nColGrd, nPQntC7] := nVal
                        //Manipular o aCols para que o usuário visualize os valores pré-carregados
                        aCols[nLinGrd, nColGrd] := nVal
            aLotes[nNewLast, nPLote            //Manipular o totalizador, se houver
                        If nPSum > 0
                            oGrade:aSumCpos[nPSum, 2] := cNewLote+= nVal
                        EndIf
                    EndIf
                Next nLinGrd
            EndIf
        EndDoEndIf
    EndIf

Return aLotes
  

    //Restaura a área das tabelas
    AEval(aAreas, {|x| RestArea(x)})
Return