Árvore de páginas

Versões comparadas

Chave

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

PCPA200 - Estrutura de Produtos

Linha de Produto:

Protheus

Segmento:

Manufatura

Módulo:

SIGAPCP - Planejamento e Controle da Produção

Parâmetro(s):

Para Inclusão, Alteração e Exclusão:


Nome
Tipo
Descrição
Default
Obrigatório
Referência

PARAMIXB1
Vetor

Array contendo cabeçalho da Estrutura de Produtos

XPARAMIXB2VetorArray contendo os itens que a estrutura possui.PARAMIXB3NuméricoOpção desejada: 3-Inclusão; 4-Alteração ; 5-ExclusãoX
Idiomas:Todos

País(es):

Todos

Banco(s) de Dados:

Todos

Sistema(s) Operacional(is):

Todos

.

"G1_COD": Código do produto pai.

"G1_QUANT":  Quantidade base do produto pai.

"ATUREVSB1": Indica se deve gerar nova revisão quando MV_REVAUT = .F. Opções  "S" (sim) ou "N" (não).

"NIVALT": Indica se deve recalcular os níveis da estrutura. Opções  "S" (sim) ou "N" (não).

Para opção 4 - Alteração, é possível definir que revisão do produto pai deverá ser considerada para a alteração.

"AUTREVPAI": determina que revisão do produto pai será considerada para a alteração. Se não for informado, será considerada a revisão atual.




X



PARAMIXB2
Vetor

Array contendo os componentes que irão compor a estrutura. De acordo com a tabela SG1.









PARAMIXB3
Numérico
Opção desejada: 3-Inclusão; 4-Alteração; 5-Exclusão.


X


Idiomas:Todos

País(es):

Todos

Banco(s) de Dados:

Todos

Sistema(s) Operacional(is):

Todos


Descrição:

A estrutura bill of materials demonstra como um produto é montado em todos os seus níveis, apresentando seus componentes e quantidades em forma de árvore com cada elemento ligado ao nível superior (produto "pai").

É com base nas estruturas que uma Ordem de Produção gera os empenhos dos componentes do produto para sua produção, permitindo a requisição automática deste material, baixa dos materiais e apuração do custo do produto.

Para determinar a fabricação/montagem é preciso que se tenha a relação dos componentes + mão de obra adequada e, se necessário, produtos fantasma para formação do produto acabado ou intermediário.


  • Conjunto

  • Componentes

  • Quantidade

Quantidade utilizada para fabricação de uma unidade de conjunto. No caso de mão de obra, deve-se informar como quantidade, o tempo padrão gasto em cada centro de custo.

Para empenho e compra do produto,

Descrição:

A estrutura bill of materials demonstra como um produto é montado em todos os seus níveis, apresentando seus componentes e quantidades em forma de árvore com cada elemento ligado ao nível superior (produto "pai").

É com base nas estruturas que uma Ordem de Produção gera os empenhos dos componentes do produto para sua produção, permitindo a requisição automática deste material, baixa dos materiais e apuração do custo do produto.

Para determinar a fabricação/montagem é preciso que se tenha a relação dos componentes + mão de obra adequada e, se necessário, produtos fantasma para formação do produto acabado ou intermediário.

  • Conjunto
  • Componentes
  • Quantidade

Quantidade utilizada para fabricação de uma unidade de conjunto. No caso de mão de obra, deve-se informar como quantidade, o tempo padrão gasto em cada centro de custo.

Para empenho e compra do produto, é solicitada a quantidade normal que deve ser utilizada no conjunto acrescida do percentual de perda, se definido.

Unidades de Medidas

Para informar quais as unidades de medidas que serão utilizadas na validação do cadastro de estrutura deve-se configurar o parâmetro "MV_CONSDUM".

Ao cadastrar uma nova estrutura de produtos é verificada a quantidade base juntamente com as quantidades informadas em seus componentes, consistindo assim possíveis diferenças. Caso o parâmetro não exista, o sistema utilizará a unidade de medida padrão para validação, que é quilo (KG).

Obs.: No campo conteúdo, as unidades de medida a serem consideradas deverão ser separadas pelo símbolo – “/” .

Exemplo Inclusão/Alteração/Exclusão:


code
Bloco de código
languagecpp
firstline1
titleExemplo Inclusão/Alteração/Exclusão:
linenumberstrue
collapsetrue
#INCLUDE 'Protheus.ch'

User Function MyPCPA200(nOpc)    Local
Local nOpcaCab := Aviso("EXECAUTO","Qual operação?",{"Alterar","Incluir","Excluir","Sair"},2)
    DoLocal Case        CaseaItem nOpc == 1 //Alterar empenho            runPCPA200(4)        Case nOpc == 2 //Incluir empenho            runPCPA200(3)        Case nOpc == 3 //Excluir empenho            runPCPA200(5)    EndCase    If nOpc != 4        U_MyPCPA200()    EndIfReturn
Static Function runPCPA200(nOpc)    Local aCab := {}    Local aItem := {}    Local aGets  := {}    Local cString := ""    Local cProdutos := ""
    Private lMsErroAuto := .F.
    Default:= {}
Local aGets := {}
Local cString := ""
Local cProdutos := ""

Private lMsErroAuto := .F.

Default nOpc := 3

    ConOutConOut(Repl("-",80))    ConOut
ConOut(PadC("Teste de rotina automatica para estrutura de produtos",80))
    
//Verifica se os produtos que serão utilizados existem cadastrados.    SB1
SB1->(dbSetOrder(1))    If
If !SB1->(dbSeek(xFilial("SB1")+"PA001"))        cProdutos
   cProdutos += "PA001, "    EndIf
EndIf

    IfIf !SB1->(dbSeek(xFilial("SB1")+"PI001"))        cProdutos
   cProdutos += "PI001, "    EndIf
EndIf

    IfIf !SB1->(dbSeek(xFilial("SB1")+"PI002"))        cProdutos
   cProdutos += "PI002, "    EndIf
EndIf

    IfIf !SB1->(dbSeek(xFilial("SB1")+"PI003"))        cProdutos
   cProdutos += "PI003, "    EndIf
EndIf

    IfIf !SB1->(dbSeek(xFilial("SB1")+"MP001"))        cProdutos
   cProdutos += "MP001, "    EndIf
EndIf

    IfIf !SB1->(dbSeek(xFilial("SB1")+"MP002"))        cProdutos
   cProdutos += "MP002, "    EndIf
EndIf

    IfIf !SB1->(dbSeek(xFilial("SB1")+"MP003"))        cProdutos
   cProdutos += "MP003, "    EndIf
EndIf

    IfIf !Empty(cProdutos)        Alert
   Alert("Cadastre os seguintes produtos: " + PadR(cProdutos,Len(cProdutos)-2))        Return    EndIf
    If
   Return
EndIf

If nOpc == 3        aCab3
   aCab := {{"G1_COD"   , "PA001" , NIL},; //Código do produto PAI.         {
            {"G1_QUANT" , 5       , NIL},; //Quantidade base do produto PAI.        
            {"ATUREVSB1", "N"     , NIL},; //A variável ATUREVSB1 é utilizada para gerar nova revisão quando MV_REVAUT=.F.        
            {"NIVALT"   , "S"     , NIL}}  //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.

           //Adiciona o componente MP001 com sequência em branco na estrutura do PA001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PA001"         , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP001"         , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3) ,        , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1               , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01"), NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49"), NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0               , NIL})        aadd
   aadd(aItem,aGets)

           //Adiciona o componente PI001 com sequência em branco na estrutura do PA001.        aGets
   aGets := {}        aadd
   aadd(aGets, {"G1_COD"  ,"PA001"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" ,"PI001"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  ,Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" ,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" ,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  ,CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  ,CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente MP001 com sequência "001" na estrutura do PA001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  ,"PA001"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" ,"MP001"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  ,"001"            , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" ,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" ,0 , NIL})        aadd(aGets,                , NIL})
   aadd(aGets, {"G1_INI"  ,CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  ,CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)                
 
   //Adiciona o componente MP001 com sequência "005" na estrutura do PA001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  ,"PA001"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" ,"MP001"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  ,"005"            , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" ,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" ,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  ,CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  ,CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)

           //Adiciona o componente MP001 na estrutura do PA001.         
   //Como o G1_TRT não foi informado no array, o programa irá criar um novo TRT para este 
           //componente, pois ele já está informado nesta estrutura.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PA001"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP001"          , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)

           //Adiciona o componente MP002 com sequência em branco na estrutura do PA001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PA001"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP002"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 2,2                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)

           //Adiciona o componente MP003 com sequência em branco na estrutura do PA001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PA001"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP003"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente MP003 com sequência em branco na estrutura do PI001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI001"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP003"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3) ,         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 3,3                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente MP002 com sequência em branco na estrutura do PI001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI001" ,          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP002"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente MP001 com sequência em branco na estrutura do PI001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI001"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP001"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd(aGets, 
   aadd(aGets, {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)

           //Adiciona o componente PI002 com sequência em branco na estrutura do PI001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI001"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "PI002"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente MP001 com sequência em branco na estrutura do PI002.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI002" ,          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP001"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente MP002 com sequência em branco na estrutura do PI002.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI002"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP002"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd(aGets, 
   aadd(aGets, {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)

           //Adiciona o componente MP003 com sequência em branco na estrutura do PI002.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI002"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP003"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente PI003 com sequência em branco na estrutura do PI002.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI002" ,          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "PI003"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente MP001 com sequência em branco na estrutura do PI003.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI003"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP001"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd(aGets, 
   aadd(aGets, {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)

           //Adiciona o componente MP002 com sequência em branco na estrutura do PI003.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI003"          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP002"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente MP003 com sequência em branco na estrutura do PI003.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  , "PI003" ,          , NIL})        aadd
   aadd(aGets,  {"G1_COMP" , "MP003"          , NIL})        aadd
   aadd(aGets,  {"G1_TRT"  , Space(3)         , NIL})        aadd
   aadd(aGets,  {"G1_QUANT" , 1,1                , NIL})        aadd
   aadd(aGets,  {"G1_PERDA" , 0,0                , NIL})        aadd
   aadd(aGets,  {"G1_INI"  , CTOD("01/01/01") , NIL})        aadd
   aadd(aGets,  {"G1_FIM"  , CTOD("31/12/49") , NIL})        aadd
   aadd(aItem,aGets)
        ConOut
   ConOut("Teste de Inclusao")        ConOut("Inicio: "+Time())        nStart := Seconds()        MSExecAuto(
   MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,aItem,3) //Inclusao        ConOut("Fim: " + cValToChar(Seconds()-nStart) + " Segundos.")    ElseIfInclusão
   ConOut("Fim inclusao.")
ElseIf nOpc == 4        4
   //--------------- Exemplo de Alteração ------------------------------------        aCab
   aCab := {{"G1_COD"   , "PA001" , NIL},; //Código do produto PAI.        
            {"G1_QUANT" , 5       , NIL},; //Quantidade base do produto PAI.        
 {"ATUREVSB1", "S" ,           {"ATUREVSB1", "S"     , NIL},; //A variável ATUREVSB1 é utilizada para gerar nova revisão quando MV_REVAUT=.F.                
            {"AUTREVPAI", "   "   , NIL},; //A variável AUTREVPAI é utilizada para indicar qual a revisão do produto pai será considerada. Caso não seja enviado, será utilizada a revisão atual do produto.        
            {"NIVALT"   , "S"     , NIL}}  //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.                
 
   //Altera o componente MP001 com sequência em branco.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  ,"PA001"          ,NIL})        aadd
   aadd(aGets,  {"G1_COMP" ,"MP001"          ,NIL})        aadd
   aadd(aGets,  {"G1_TRT"  ,Space(3)         ,NIL})        aadd
   aadd(aGets,  {"G1_QUANT" ,10               ,NIL})        aadd
   aadd(aGets,  {"G1_PERDA" ,1                ,NIL})        aadd
   aadd(aGets,  {"G1_INI"  ,CTOD("01/01/20") ,NIL})        aadd
   aadd(aGets,  {"G1_FIM"  ,CTOD("31/12/49") ,NIL})        aAdd
   aAdd(aGets, {"LINPOS"  ,"G1_COD+G1_COMP+G1_TRT","PA001","MP001",Space(3)})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente PI003 com sequência em branco na estrutura do PA001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  ,"PA001"          ,NIL})        aadd
   aadd(aGets,  {"G1_COMP" ,"PI003"          ,NIL})        aadd
   aadd(aGets,  {"G1_TRT"  ,Space(3)         ,NIL})        aadd
   aadd(aGets,  {"G1_QUANT" ,5                ,NIL})        aadd
   aadd(aGets,  {"G1_PERDA" ,1                ,NIL})        aadd
   aadd(aGets,  {"G1_INI"  ,CTOD("01/01/20") ,NIL})        aadd
   aadd(aGets,  {"G1_FIM"  ,CTOD("31/12/49") ,NIL})        aadd
   aadd(aItem,aGets)
        
   //Deleta o componente MP002 da estrutura do PA001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  ,"PA001"          ,NIL})        aadd
   aadd(aGets,  {"G1_COMP" ,"MP002"          ,NIL})        aadd
   aadd(aGets,  {"G1_TRT"  ,Space(3)         ,NIL})        aadd
   aadd(aGets,  {"G1_QUANT" ,5                ,NIL})        aadd
   aadd(aGets,  {"G1_PERDA" ,1                ,NIL})        aadd
   aadd(aGets,  {"G1_INI"  ,CTOD("01/01/20") ,NIL})        aadd
   aadd(aGets,  {"G1_FIM"  ,CTOD("31/12/49") ,NIL})        aAdd
   aAdd(aGets, {"LINPOS"  ,"G1_COD+G1_COMP+G1_TRT","PA001","MP002",Space(3)})        aAdd
   aAdd(aGets, {"AUTDELETA","S"             ,NIL})        aadd
   aadd(aItem,aGets)
        
   //Adiciona o componente PI002 com sequência "001" na estrutura do PI001.        aGets
   aGets := {}        aadd
   aadd(aGets,  {"G1_COD"  ,"PI001"          ,NIL})        aadd
   aadd(aGets,  {"G1_COMP" ,"PI002" ,NIL})        aadd          ,NIL})
   aadd(aGets,  {"G1_TRT"  ,"001"            ,NIL})        aadd
   aadd(aGets,  {"G1_QUANT" ,5                ,NIL})        aadd
   aadd(aGets,  {"G1_PERDA" ,1                ,NIL})        aadd
   aadd(aGets,  {"G1_INI"  ,CTOD("01/01/20") ,NIL})        aadd
   aadd(aGets,  {"G1_FIM"  ,CTOD("31/12/49") ,NIL})        aadd
   aadd(aItem,aGets)
        ConOut
   ConOut("Teste de Alteracao")        ConOut("Inicio: "+Time())        nStart := Seconds()        MSExecAuto
   MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,aItem,4) //Alteração        ConOut("Fim: " + cValToChar(Seconds()-nStart) + " SegundosAlteração
   ConOut("Fim alteracao.")
    ElseIf
ElseIf nOpc == 5        5
   //--------------- Exemplo de Exclusao ------------------------------------        SG1
   SG1->(dbSetOrder(1))        
   //Verifica se o produto PA001 possui estrutura. Se existir, executa a exclusão.        If
   If SG1->(dbSeek(xFilial("SG1")+"PA001"))            aCab
      aCab := {{"G1_COD" , "PA001" , NIL},;            
               {"NIVALT" , "S"     , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.                        ConOut
 
      ConOut("Teste de Exclusao do codigo PA001")            MSExecAuto
      MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,NIL,5) //Exclusao            ConOutExclusao
      ConOut("Fim exclusao do codigo PA001.")        EndIf                
   EndIf
 
   //Verifica se não aconteceu nenhum erro, e tenta excluir a estrutura do PI001 se existir.        If
   If !lMsErroAuto .And. SG1->(dbSeek(xFilial("SG1")+"PI001"))            aCab
      aCab := {{"G1_COD" , "PI001" , NIL},;            
               {"NIVALT" , "S"     , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.
            ConOut
      ConOut("Teste de Exclusao do codigo PI001")            MSExecAuto
      MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,NIL,5) //Exclusao            ConOutExclusao
      ConOut("Fim exclusao do codigo PI001.")        EndIf
        
   EndIf

   //Verifica se não aconteceu nenhum erro, e tenta excluir a estrutura do PI002 se existir.        If
 !lMsErroAuto   If !lMsErroAuto .And. SG1->(dbSeek(xFilial("SG1")+"PI002"))            aCab
      aCab := {{"G1_COD" , "PI002" , NIL},;            
               {"NIVALT" , "S"     , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.
            ConOut

      ConOut("Teste de Exclusao do codigo PI002")            MSExecAuto
      MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,NIL,5) //Exclusao            ConOutExclusao
      ConOut("Fim exclusao do codigo PI002.")        EndIf        
   EndIf

   //Verifica se não aconteceu nenhum erro, e tenta excluir a estrutura do PI003 se existir.        If
   If !lMsErroAuto .And. SG1->(dbSeek(xFilial("SG1")+"PI003"))            aCab
      aCab := {{"G1_COD" , "PI003" , NIL},;            
               {"NIVALT" , "S"  , NIL  , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.
            ConOut
      ConOut("Teste de Exclusao do codigo PI003")            MSExecAuto
      MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,NIL,5) //Exclusao            ConOutExclusao
      ConOut("Fim exclusao do codigo PI003.")        EndIf    EndIf
    
   EndIf
EndIf

//Verifica se ocorreu algum erro, e exibe a mensagem.    If lMsErroAuto        If
If lMsErroAuto
   If IsBlind()            If
      If IsTelnet()                VTDispFile
         VTDispFile(NomeAutoLog(),.t.)            Else                cString
      Else
         cString := MemoRead(NomeAutoLog())                Conout
         Conout("Aviso de Erro:",cString)            EndIf        Else            MostraErro()        EndIf    Else        MsgInfo
      EndIf
   Else
      MostraErro()
   EndIf
Else
   MsgInfo("Operação realizada com sucesso","OK")    EndIf    ConOut
EndIf
ConOut(Repl("-",80))
Return

Sintaxe:

PCPA200 - Estrutura de Produtos ( PARAMIXB1, PARAMIXB2, PARAMIXB3 ) --> Nil

Retorno:

Nil (nulo)

   Nil

Observações:Na opção exclusão, não é necessário a utilização do segundo parâmetro (PARAMIXB2), pois serão excluídos todos os componentes relacionados ao produto pai informado no cabeçalho da rotina automática (PARAMIXB1)
#INCLUDE 'Protheus.ch'
User Function MyPCPA200()
    Local nOpc := Aviso("EXECAUTO","Qual operação?",{"Alterar","Incluir","Excluir","Sair"},2)
    Do Case
        Case nOpc == 1 //Alterar empenho
            runPCPA200(4)
        Case nOpc == 2 //Incluir empenho
            runPCPA200(3)
        Case nOpc == 3 //Excluir empenho
            runPCPA200(5)
    EndCase
    If nOpc != 4
        U_MyPCPA200()
    EndIf
Return
Static Function runPCPA200(nOpc)
    Local aCab := {}
    Local aItem := {}
    Local aGets  := {}
    Local cString := ""
    Local cProdutos := ""
    Private lMsErroAuto := .F.
    Default nOpc := 3
    ConOut(Repl("-",80))
    ConOut(PadC("Teste de rotina automatica para estrutura de produtos",80))
    //Verifica se os produtos que serão utilizados existem cadastrados.
    SB1->(dbSetOrder(1))
    If !SB1->(dbSeek(xFilial("SB1")+"PA001"))
        cProdutos += "PA001, "
    EndIf
    If !SB1->(dbSeek(xFilial("SB1")+"PI001"))
        cProdutos += "PI001, "
    EndIf
    If !SB1->(dbSeek(xFilial("SB1")+"PI002"))
        cProdutos += "PI002, "
    EndIf
    If !SB1->(dbSeek(xFilial("SB1")+"PI003"))
        cProdutos += "PI003, "
    EndIf
    If !SB1->(dbSeek(xFilial("SB1")+"MP001"))
        cProdutos += "MP001, "
    EndIf
    If !SB1->(dbSeek(xFilial("SB1")+"MP002"))
        cProdutos += "MP002, "
    EndIf
    If !SB1->(dbSeek(xFilial("SB1")+"MP003"))
        cProdutos += "MP003, "
    EndIf
    If !Empty(cProdutos)
        Alert("Cadastre os seguintes produtos: " + PadR(cProdutos,Len(cProdutos)-2))
        Return
    EndIf
    If nOpc == 3
        aCab := {{"G1_COD" , "PA001" , NIL},; //Código do produto PAI.
         {"G1_QUANT" , 5 , NIL},; //Quantidade base do produto PAI.
         {"ATUREVSB1", "N" , NIL},; //A variável ATUREVSB1 é utilizada para gerar nova revisão quando MV_REVAUT=.F.
         {"NIVALT" , "S" , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.
        //Adiciona o componente MP001 com sequência em branco na estrutura do PA001.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PA001" , NIL})
        aadd(aGets, {"G1_COMP" , "MP001" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01"), NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49"), NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente PI001 com sequência em branco na estrutura do PA001.
        aGets := {}
        aadd(aGets, {"G1_COD" ,"PA001" , NIL})
        aadd(aGets, {"G1_COMP" ,"PI001" , NIL})
        aadd(aGets, {"G1_TRT" ,Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" ,1 , NIL})
        aadd(aGets, {"G1_PERDA" ,0 , NIL})
        aadd(aGets, {"G1_INI" ,CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" ,CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP001 com sequência "001" na estrutura do PA001.
        aGets := {}
        aadd(aGets, {"G1_COD" ,"PA001" , NIL})
        aadd(aGets, {"G1_COMP" ,"MP001" , NIL})
        aadd(aGets, {"G1_TRT" ,"001" , NIL})
        aadd(aGets, {"G1_QUANT" ,1 , NIL})
        aadd(aGets, {"G1_PERDA" ,0 , NIL})
        aadd(aGets, {"G1_INI" ,CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" ,CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        
        //Adiciona o componente MP001 com sequência "005" na estrutura do PA001.
        aGets := {}
        aadd(aGets, {"G1_COD" ,"PA001" , NIL})
        aadd(aGets, {"G1_COMP" ,"MP001" , NIL})
        aadd(aGets, {"G1_TRT" ,"005" , NIL})
        aadd(aGets, {"G1_QUANT" ,1 , NIL})
        aadd(aGets, {"G1_PERDA" ,0 , NIL})
        aadd(aGets, {"G1_INI" ,CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" ,CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP001 na estrutura do PA001.
        //Como o G1_TRT não foi informado no array, o programa irá criar um novo TRT para este
        //componente, pois ele já está informado nesta estrutura.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PA001" , NIL})
        aadd(aGets, {"G1_COMP" , "MP001" , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP002 com sequência em branco na estrutura do PA001.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PA001" , NIL})
        aadd(aGets, {"G1_COMP" , "MP002" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 2 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP003 com sequência em branco na estrutura do PA001.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PA001" , NIL})
        aadd(aGets, {"G1_COMP" , "MP003" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP003 com sequência em branco na estrutura do PI001.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI001" , NIL})
        aadd(aGets, {"G1_COMP" , "MP003" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 3 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP002 com sequência em branco na estrutura do PI001.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI001" , NIL})
        aadd(aGets, {"G1_COMP" , "MP002" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP001 com sequência em branco na estrutura do PI001.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI001" , NIL})
        aadd(aGets, {"G1_COMP" , "MP001" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente PI002 com sequência em branco na estrutura do PI001.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI001" , NIL})
        aadd(aGets, {"G1_COMP" , "PI002" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP001 com sequência em branco na estrutura do PI002.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI002" , NIL})
        aadd(aGets, {"G1_COMP" , "MP001" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP002 com sequência em branco na estrutura do PI002.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI002" , NIL})
        aadd(aGets, {"G1_COMP" , "MP002" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP003 com sequência em branco na estrutura do PI002.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI002" , NIL})
        aadd(aGets, {"G1_COMP" , "MP003" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente PI003 com sequência em branco na estrutura do PI002.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI002" , NIL})
        aadd(aGets, {"G1_COMP" , "PI003" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP001 com sequência em branco na estrutura do PI003.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI003" , NIL})
        aadd(aGets, {"G1_COMP" , "MP001" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP002 com sequência em branco na estrutura do PI003.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI003" , NIL})
        aadd(aGets, {"G1_COMP" , "MP002" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        //Adiciona o componente MP003 com sequência em branco na estrutura do PI003.
        aGets := {}
        aadd(aGets, {"G1_COD" , "PI003" , NIL})
        aadd(aGets, {"G1_COMP" , "MP003" , NIL})
        aadd(aGets, {"G1_TRT" , Space(3) , NIL})
        aadd(aGets, {"G1_QUANT" , 1 , NIL})
        aadd(aGets, {"G1_PERDA" , 0 , NIL})
        aadd(aGets, {"G1_INI" , CTOD("01/01/01") , NIL})
        aadd(aGets, {"G1_FIM" , CTOD("31/12/49") , NIL})
        aadd(aItem,aGets)
        ConOut("Teste de Inclusao")
        ConOut("Inicio: "+Time())
        nStart := Seconds()
        MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,aItem,3) //Inclusao
        ConOut("Fim: " + cValToChar(Seconds()-nStart) + " Segundos.")
    ElseIf nOpc == 4
        //--------------- Exemplo de Alteração ------------------------------------
        aCab := {{"G1_COD" , "PA001" , NIL},; //Código do produto PAI.
         {"G1_QUANT" , 5 , NIL},; //Quantidade base do produto PAI.
         {"ATUREVSB1", "S" , NIL},; //A variável ATUREVSB1 é utilizada para gerar nova revisão quando MV_REVAUT=.F.
                 {"AUTREVPAI", " " , NIL},; //A variável AUTREVPAI é utilizada para indicar qual a revisão do produto pai será considerada. Caso não seja enviado, será utilizada a revisão atual do produto.
         {"NIVALT" , "S" , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.
        
        //Altera o componente MP001 com sequência em branco.
        aGets := {}
        aadd(aGets, {"G1_COD" ,"PA001" ,NIL})
        aadd(aGets, {"G1_COMP" ,"MP001" ,NIL})
        aadd(aGets, {"G1_TRT" ,Space(3) ,NIL})
        aadd(aGets, {"G1_QUANT" ,10 ,NIL})
        aadd(aGets, {"G1_PERDA" ,1 ,NIL})
        aadd(aGets, {"G1_INI" ,CTOD("01/01/20") ,NIL})
        aadd(aGets, {"G1_FIM" ,CTOD("31/12/49") ,NIL})
        aAdd(aGets, {"LINPOS" ,"G1_COD+G1_COMP+G1_TRT","PA001","MP001",Space(3)})
        aadd(aItem,aGets)
        //Adiciona o componente PI003 com sequência em branco na estrutura do PA001.
        aGets := {}
        aadd(aGets, {"G1_COD" ,"PA001" ,NIL})
        aadd(aGets, {"G1_COMP" ,"PI003" ,NIL})
        aadd(aGets, {"G1_TRT" ,Space(3) ,NIL})
        aadd(aGets, {"G1_QUANT" ,5 ,NIL})
        aadd(aGets, {"G1_PERDA" ,1 ,NIL})
        aadd(aGets, {"G1_INI" ,CTOD("01/01/20") ,NIL})
        aadd(aGets, {"G1_FIM" ,CTOD("31/12/49") ,NIL})
        aadd(aItem,aGets)
        //Deleta o componente MP002 da estrutura do PA001.
        aGets := {}
        aadd(aGets, {"G1_COD" ,"PA001" ,NIL})
        aadd(aGets, {"G1_COMP" ,"MP002" ,NIL})
        aadd(aGets, {"G1_TRT" ,Space(3) ,NIL})
        aadd(aGets, {"G1_QUANT" ,5 ,NIL})
        aadd(aGets, {"G1_PERDA" ,1 ,NIL})
        aadd(aGets, {"G1_INI" ,CTOD("01/01/20") ,NIL})
        aadd(aGets, {"G1_FIM" ,CTOD("31/12/49") ,NIL})
        aAdd(aGets, {"LINPOS" ,"G1_COD+G1_COMP+G1_TRT","PA001","MP002",Space(3)})
        aAdd(aGets, {"AUTDELETA","S" ,NIL})
        aadd(aItem,aGets)
        //Adiciona o componente PI002 com sequência "001" na estrutura do PI001.
        aGets := {}
        aadd(aGets, {"G1_COD" ,"PI001" ,NIL})
        aadd(aGets, {"G1_COMP" ,"PI002" ,NIL})
        aadd(aGets, {"G1_TRT" ,"001" ,NIL})
        aadd(aGets, {"G1_QUANT" ,5 ,NIL})
        aadd(aGets, {"G1_PERDA" ,1 ,NIL})
        aadd(aGets, {"G1_INI" ,CTOD("01/01/20") ,NIL})
        aadd(aGets, {"G1_FIM" ,CTOD("31/12/49") ,NIL})
        aadd(aItem,aGets)
        ConOut("Teste de Alteracao")
        ConOut("Inicio: "+Time())
        nStart := Seconds()
        MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,aItem,4) //Alteração
        ConOut("Fim: " + cValToChar(Seconds()-nStart) + " Segundos.")
    ElseIf nOpc == 5
        //--------------- Exemplo de Exclusao ------------------------------------
        SG1->(dbSetOrder(1))
        //Verifica se o produto PA001 possui estrutura. Se existir, executa a exclusão.
        If SG1->(dbSeek(xFilial("SG1")+"PA001"))
            aCab := {{"G1_COD" , "PA001" , NIL},;
             {"NIVALT" , "S" , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.
            
            ConOut("Teste de Exclusao do codigo PA001")
            MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,NIL,5) //Exclusao
            ConOut("Fim exclusao do codigo PA001.")
        EndIf
        
        //Verifica se não aconteceu nenhum erro, e tenta excluir a estrutura do PI001 se existir.
        If !lMsErroAuto .And. SG1->(dbSeek(xFilial("SG1")+"PI001"))
            aCab := {{"G1_COD" , "PI001" , NIL},;
             {"NIVALT" , "S" , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.
            ConOut("Teste de Exclusao do codigo PI001")
            MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,NIL,5) //Exclusao
            ConOut("Fim exclusao do codigo PI001.")
        EndIf
        //Verifica se não aconteceu nenhum erro, e tenta excluir a estrutura do PI002 se existir.
        If !lMsErroAuto .And. SG1->(dbSeek(xFilial("SG1")+"PI002"))
            aCab := {{"G1_COD" , "PI002" , NIL},;
             {"NIVALT" , "S" , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.
            ConOut("Teste de Exclusao do codigo PI002")
            MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,NIL,5) //Exclusao
            ConOut("Fim exclusao do codigo PI002.")
        EndIf
        //Verifica se não aconteceu nenhum erro, e tenta excluir a estrutura do PI003 se existir.
        If !lMsErroAuto .And. SG1->(dbSeek(xFilial("SG1")+"PI003"))
            aCab := {{"G1_COD" , "PI003" , NIL},;
             {"NIVALT" , "S" , NIL}} //A variável NIVALT é utilizada para recalcular ou não os níveis da estrutura.
            ConOut("Teste de Exclusao do codigo PI003")
            MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,NIL,5) //Exclusao
            ConOut("Fim exclusao do codigo PI003.")
        EndIf
    EndIf
    //Verifica se ocorreu algum erro, e exibe a mensagem.
    If lMsErroAuto
        If IsBlind()
            If IsTelnet()
                VTDispFile(NomeAutoLog(),.t.)
            Else
                cString := MemoRead(NomeAutoLog())
                Conout("Aviso de Erro:",cString)
            EndIf
        Else
            MostraErro()
        EndIf
    Else
        MsgInfo("Operação realizada com sucesso","OK")
    EndIf
    ConOut(Repl("-",80))
Dica
titleRevisões

Para realizar a alteração em alguma revisão específica da estrutura, pode ser enviado no primeiro parâmetro (PARAMIXB1) a revisão desejada. A revisão deve estar identificada pelo parâmetro "AUTREVPAI" conforme o exemplo acima. Caso este parâmetro não seja enviado, será utilizada a revisão atual do produto para realizar a alteração da estrutura.

Dica
titleOperação de Alteração

Para a operação de Alteração de estruturas, não é necessário enviar todos os componentes da estrutura no segundo parâmetro (PARAMIXB2). O programa irá fazer alterações somente para os componentes que forem informados no segundo parâmetro.

Para alterar um componente que faz parte da estrutura será necessário utilizar o parâmetro LINPOS, conforme exemplo acima.

Para excluir um componente que faz parte da estrutura será necessário utilizar os parâmetros LINPOS e AUTDELETA, conforme exemplo acima.

Para adicionar um novo componente na estrutura, não é necessário utilizar os parâmetro LINPOS e AUTDELETA, sendo necessário apenas as informações do componente para que a inclusão seja feita.

A operação de alteração é realizada quando o terceiro parâmetro (PARAMIXB3) é enviado com o valor 4.

Dica
titleOperação de Exclusão

Para a operação de Exclusão, o segundo parâmetro (PARAMIXB2) é ignorado pois são excluídos todos os componentes relacionados ao produto PAI, que é informado no primeiro parâmetro (PARAMIXB1).

A operação de exclusão é realizada quando o terceiro parâmetro (PARAMIXB3) é enviado com o valor 5.

Return