Árvore de páginas

Versões comparadas

Chave

  • Esta linha foi adicionada.
  • Esta linha foi removida.
  • A formatação mudou.

P145NUMOP - Manipulação do número das ordens de produção do MRP

Linha de Produto:

Protheus

Segmento:

Manufatura

Módulo:

SIGAPCP - Planejamento e Controle da Produção

Parâmetro(s):

NomeTipoDescrição
DefaultObrigatórioReferência
PARAMIXB[1]Array

Dados de rastreio do MRP.

1 - Código do produto   
2 - Sequencia na estrutura                
3 - Data de entrega
4 - Data de inicio
5 - Tipo documento pai
6 - Código documento pai (MRP)
7 - Código documento filho (MRP)
8 - Necessidade original     
9 - Saldo em estoque
10 - Baixa estrutura
11 - Quantidade substituição
12 - Quantidade empenho
13 - Necessidade
14 - Revisão da estrutura 
15 - Roteiro do produto pai
16 - Operação
17 - Roteiro produto filho
18 - Sequencia
19 - Nível do produto
20 - Local
21 - Chave
22 - Chave de substituição
23 - ID opcional
24 - Contrato
25 - Filial
26 - Recno HWC

PARAMIXB[2]CaractereOrdem de produção pai.

Idiomas:

Todos

País(es):

Todos

Banco(s) de Dados:

Todos

Sistema(s) Operacional(is):

Todos

Ponto de Entrada

Descrição:
O ponto de entrada P145NUMOP permite manipular o número das ordens de produção que serão geradas pelo MRP.
Localização:

Função PCPA145OP.

Eventos:

Após a abertura da thread para criação da ordem de produção.

Programa Fonte:PCPA145.PRW

Sintaxe:

P145NUMOP( ) → aRetorno

Retorno:

O ponto de entrada deve retornar um array com as seguintes informações:

aRetorno[1] → Valor para o campo C2_NUM;

aRetorno[2] → Valor para o campo C2_ITEM;

aRetorno[3] → Valor para o campo C2_SEQUEN;

aRetorno[4] → Valor para o campo C2_ITEMGRD;

aRetorno[5] → Valor para o campo C2_GRADE (Somente "S" ou " ").

Observações:

O controle de geração da numeração da ordem de produção deverá ser feito inteiramente dentro do ponto de entrada, inclusive tratativas para não gerar numeração duplicada no processo em multi-thread.

Bloco de código
languagec#
firstline1
titleExemplo
linenumberstrue
#INCLUDE "PROTHEUS.CH"

Static _nTamC2Num := GetSx3Cache("C2_NUM"    , "X3_TAMANHO")
Static _nTamC2Ite := GetSx3Cache("C2_ITEM"   , "X3_TAMANHO")
Static _nTamC2Seq := GetSx3Cache("C2_SEQUEN" , "X3_TAMANHO")
Static _nTamItGrd := GetSx3Cache("C2_ITEMGRD", "X3_TAMANHO")

User Function P145NumOP()
    Local aChaves    := {}
    Local aDataHWC   := PARAMIXB[1]
    Local aRetorno   := Array(5)
    Local cChaveGbl  := ""
    Local cChaveGrd  := ""
    Local cChvGrdPrd := ""
    Local cGrade     := "MONITOR"
    Local cOPPai     := PARAMIXB[2]
    Local cProduto   := ""
    Local lGrade     := .F.

    // Verifica se o produto possui grade
    cProduto := aDataHWC[1]
    // Possui grade se o código do produto iniciar com o nome da grade ou se a op pai já tiver grade
    lGrade   := SubStr(cProduto, 1, Len(cGrade)) == cGrade .Or. !Empty(SubStr(cOpPai, _nTamC2Num+_nTamC2Ite+_nTamC2Seq+1, _nTamItGrd))
 
    If !lGrade
        // Sem grade de produto
        If Empty(cOPPai)
            aRetorno[1] := GetNumSC2(.T.) //C2_NUM
            aRetorno[2] := "01"           //C2_ITEM
            aRetorno[3] := "001"          //C2_SEQUEN
            aRetorno[4] := "   "          //C2_ITEMGRD
            aRetorno[5] := " "            //C2_GRADE

            // Monta chave global
            cChaveGbl := "NUM_OP" + aRetorno[1] + aRetorno[2] 
            
            // Guarda a sequencia na global para incrementar depois
            PutGlbValue(cChaveGbl, aRetorno[3])
        Else
            aRetorno[1] := SubStr(cOpPai, 1, _nTamC2Num)
            aRetorno[2] := SubStr(cOpPai, _nTamC2Num+1, _nTamC2Ite)
            aRetorno[4] := "   "
            aRetorno[5] := " "
            
            // Monta chave global
            cChaveGbl := "NUM_OP" + aRetorno[1] + aRetorno[2]
            
            // Tenta adquirir o lock da global
            While !GlbNmLock(cChaveGbl)
                Sleep(100)
            End

            // Recupera a sequencia anterior da global
            aRetorno[3] := GetGlbValue(cChaveGbl)

            // Incrementa a sequencia
            aRetorno[3] := Soma1(aRetorno[3])

            // Salva nova sequencia na global
            PutGlbValue(cChaveGbl, aRetorno[3])
            
            // Libera o lock para outras threads
            GlbNmUnlock(cChaveGbl)
        EndIf
    Else
        // Com grade de produto
        If Empty(cOPPai)
            // Monta a chave da global que irá armazenar o número das ops desta grade
            cChvGrdPrd := "GRADE_PRODUTO_" + cGrade
            
            // Adquire o lock
            While !GlbNmLock(cChvGrdPrd)
                Sleep(100)
            End

            // Recupera o número da op desta grade
            aRetorno[1] := GetGlbValue(cChvGrdPrd)
            
            // Gera o número da op se não existir.
            If Empty(aRetorno[1])
                aRetorno[1] := GetNumSC2(.T.)
            EndIf

            // Guarda o número da op para os outros produtos da grade
            PutGlbValue(cChvGrdPrd, aRetorno[1])

            // Libera o lock para outras threads
            GlbNmUnlock(cChvGrdPrd)

            aRetorno[2] := "01"
            aRetorno[3] := "001"
            aRetorno[5] := "S"

            // Monta a chave para controlar o item da grade
            cChaveGrd := "GRADE_OP" + aRetorno[1] + aRetorno[2] + aRetorno[3]

            // Tenta adquirir o lock da global
            While !GlbNmLock(cChaveGrd)
                Sleep(100)
            End

            // Recupera o valor do item grade
            aRetorno[4] := GetGlbValue(cChaveGrd)
            
            // Se não existir inicia o primeiro item, se não incrementa
            If Empty(aRetorno[4])
                aRetorno[4] := "001"
            Else
                aRetorno[4] := Soma1(aRetorno[4])
            EndIf
            
            // Grava o novo item grade na global
            PutGlbValue(cChaveGrd, aRetorno[4])
            
            // Libera o lock para outras threads
            GlbNmUnlock(cChaveGrd)

            // Monta chave global
            cChaveGbl := "NUM_OP" + aRetorno[1] + aRetorno[2] + aRetorno[4]
            
            // Guarda a sequencia na global para incrementar depois
            PutGlbValue(cChaveGbl, aRetorno[3])
            
            While !GlbNmLock("CHAVES_P145NUMOP")
                Sleep(100)
            End

            // Salva as chaves para limpar no fim do processamento
            If GetGlbVars("CHAVES_P145NUMOP", @aChaves)
                aAdd(aChaves, cChvGrdPrd)
                aAdd(aChaves, cChaveGrd)
                PutGlbVars("CHAVES_P145NUMOP", aChaves)
            Else
                PutGlbVars("CHAVES_P145NUMOP", {cChvGrdPrd, cChaveGrd})
            EndIf

            GlbNmUnlock("CHAVES_P145NUMOP")
        Else
            // Recupera valores da op pai
            aRetorno[1] := SubStr(cOpPai, 1, _nTamC2Num)
            aRetorno[2] := SubStr(cOpPai, _nTamC2Num+1, _nTamC2Ite)
            aRetorno[4] := SubStr(cOpPai, _nTamC2Num+_nTamC2Ite+_nTamC2Seq+1, _nTamItGrd)
            aRetorno[5] := "S"

            // Monta chave global
            cChaveGbl := "NUM_OP" + aRetorno[1] + aRetorno[2] + aRetorno[4]
            
            // Tenta adquirir o lock da global
            While !GlbNmLock(cChaveGbl)
                Sleep(100)
            End

            // Recupera a sequencia anterior da global
            aRetorno[3] := GetGlbValue(cChaveGbl)

            // Incrementa a sequencia
            aRetorno[3] := Soma1(aRetorno[3])

            // Salva nova sequencia na global
            PutGlbValue(cChaveGbl, aRetorno[3])
            
            // Libera o lock para outras threads
            GlbNmUnlock(cChaveGbl)
        EndIf

    EndIf

    While !GlbNmLock("CHAVES_P145NUMOP")
        Sleep(100)
    End

    // Salva as chaves para limpar no fim do processamento
    If GetGlbVars("CHAVES_P145NUMOP", @aChaves)
        aAdd(aChaves, cChaveGbl)
        PutGlbVars("CHAVES_P145NUMOP", aChaves)
    Else
        PutGlbVars("CHAVES_P145NUMOP", {cChaveGbl})
    EndIf

    GlbNmUnlock("CHAVES_P145NUMOP")

Return aRetorno

// Ponto de entrada executado no final da geração de documentos
User Function PA145GER()
    Local nTotal := 0
    Local nIndex := 0
    Local cChave := ""
    Local aChaves := {}

    // Recupera as chaves utilizadas no processamento do ponto de entrada P145NumOP
    If GetGlbVars("CHAVES_P145NUMOP", @aChaves)
        nTotal  := Len(aChaves)
        
        // Percorre as chaves limpando as globais
        For nIndex := 1 To nTotal
            cChave := aChaves[nIndex]
            ClearGlbValue(cChave)
        Next
    EndIf

Return Nil