PCPA135 - Pré-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 Pré-estrutura de Produtos

X

PARAMIXB2

Vetor

Array contendo os itens que a pré-estrutura possui.

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

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

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

rotina Pré-estrutura permite simular a Criação de Estruturas de Produtos¹ que a empresa quer fabricar.

O objetivo é controlar a Criação da Estrutura do Produto antes de oficializa-la, podendo transformá-la depois em uma estrutura definitiva, se necessário.

O Sistema controla quais usuários podem transformar uma Pré-Estrutura em uma Estrutura Definitiva por meio da Senha de Usuário.

Além disso, a pré-estrutura pode ser utilizada para simulação da Formação de preços do produto, pela rotina Formação de Preços do ambiente Estoque e Custos.

Bloco de código

language	cpp
firstline	1
title	Exemplo Inclusão/Alteração/Exclusão:
linenumbers	true
collapse	true

#INCLUDE 'Protheus.ch'

User Function MyPCPA135(nOpc)
Local aCab  :={}
Local aItem := {}
Local aGets	:= {}
Local lOK	:= .T.
Local cString
Private lMsErroAuto := .F.
Default nOpc := 4

//Abertura do ambiente                                         |
RpcSetEnv( "99" , "01" , Nil, Nil, "PCP", Nil )

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 – “/” .

Bloco de código

language	cpp
firstline	1
title	Exemplo Inclusão/Alteração/Exclusão:
linenumbers	true
collapse	true

#INCLUDE 'Protheus.ch'

User Function MyPCPA200(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->(dbSeekVerificacao do ambiente para teste                           |
dbSelectArea("SB1")
dbSetOrder(1)
If !SB1->(MsSeek(xFilial("SB1")+"PA001"))
	lOk :=  cProdutos += "PA001, ".F.
	ConOut("Cadastrar produto acabado: PA001")
EndIf

If !SB1->(dbSeekMsSeek(xFilial("SB1")+"PI001"))
	lOk :=  cProdutos += "PI001, ".F.
	ConOut("Cadastrar produto intermediario: PI001")
EndIf

If !SB1->(dbSeekMsSeek(xFilial("SB1")+"PI002"))
	lOk :=  cProdutos += "PI002, ".F.
	ConOut("Cadastrar produto intermediario: PI002")
EndIf

If !SB1->(dbSeekMsSeek(xFilial("SB1")+"PI003"))
	lOk :=  cProdutos += "PI003, ".F.
	ConOut("Cadastrar produto intermediario: PA003")
EndIf

If !SB1->(dbSeekMsSeek(xFilial("SB1")+"MP001"))
	lOk :=  cProdutos += "MP001, ".F.
	ConOut("Cadastrar produto materia prima: MP001")
EndIf

If !SB1->(dbSeekMsSeek(xFilial("SB1")+"MP002"))
   cProdutos += "MP002, "	lOk := .F.
	ConOut("Cadastrar produto materia prima: MP002")
EndIf

If !SB1->(dbSeekMsSeek(xFilial("SB1")+"MP003"))
	lOk := .F.
	ConOut("Cadastrar produto cProdutosmateria +=prima: "MP003, ")
EndIf

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

If nOpc == 3
   SB1->(MsSeek(xFilial("SB1")+"MP004"))
	lOk := .F.
	ConOut("Cadastrar produto materia prima: MP004")
EndIf

If nOpc==3 .And. lOk
	aCab := {	{"G1GG_COD"   		, "PA001" 			, NIL},; //Código do produto PAI.
            {"G1_QUANT" , 5
				{"GG_QUANT"		,2		        		, 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,	{"GG_COD"		,"PA001"			,NIL})
	aadd(aGets,	{"GG_COMP"		,"PI001" 			,NIL})
	aadd(aGets,	{"GG_TRT"		,"   "   			,NIL})
	aadd(aGets,	{"GG_QUANT"		,1					,NIL})
	aadd(aGets,	{"GG_PERDA"		,0					,NIL})
	aadd(aGets,	{"GG_INI"		,CTOD("01/01/01")	,NIL})
	aadd(aGets,	{"GG_FIM"		,CTOD("31/12/49")	,NIL})
	aadd(aItem,aGets)

	aGets := {}
	aadd(aGets,	{"GG_COD"		,"PA001"			,NIL})
	aadd(aGets,	{"GG_COMP"		,"MP001"			,NIL})
	aadd(aGets,	{"GG_TRT"		,Space(3)			,NIL})
	aadd(aGets,	{"GG_QUANT"		,1					,NIL})
	aadd(aGets,	{"GG_PERDA"		,0					,NIL})
	aadd(aGets,	{"GG_INI"		,CTOD("01/01/01")	,NIL})
	aadd(aGets,	{"GG_FIM"		,CTOD("31/12/49")	,NIL})
	aadd(aItem,aGets)
	
	aGets := {}
   	aadd(aGets, 	{"G1GG_COD"  		,"PA001"          , 			,NIL})
   	aadd(aGets, 	{"G1GG_COMP" 		,"PI001"          , MP002"			,NIL})
   	aadd(aGets, 	{"G1GG_TRT"  		,Space(3)         , 			,NIL})
   	aadd(aGets, 	{"G1GG_QUANT",1                , 		,2					,NIL})
   	aadd(aGets, 	{"G1GG_PERDA",0                , 		,0					,NIL})
   	aadd(aGets, 	{"G1GG_INI"  		,CTOD("01/01/01") 	, NIL})
   	aadd(aGets, 	{"G1GG_FIM"  		,CTOD("31/12/49") 	, NIL})
   	aadd(aItem,aGets)

   //Adiciona o componente MP001 com sequência "001" na estrutura do PA001.
   	aGets := {}
   	aadd(aGets, 	{"G1GG_COD"  		,"PA001"          , PI002"			,NIL})
   	aadd(aGets, 	{"G1GG_COMP" 		,"MP001"          , MP003"			,NIL})
   	aadd(aGets, 	{"G1GG_TRT"  ,"001"            , 		,Space(3)			,NIL})
   	aadd(aGets, 	{"G1GG_QUANT",1                , 		,3					,NIL})
   	aadd(aGets, 	{"G1GG_PERDA",0                , 		,0					,NIL})
   	aadd(aGets, 	{"G1GG_INI"  		,CTOD("01/01/01") 	, NIL})
   	aadd(aGets, 	{"G1GG_FIM"  		,CTOD("31/12/49") 	, NIL})
   	aadd(aItem,aGets)
 
   //Adiciona o componente MP001 com sequência "005" na estrutura do PA001.
   
	aGets := {}
   	aadd(aGets, 	{"G1GG_COD"  		,"PA001PI002"          , 			,NIL})
   	aadd(aGets, 	{"G1GG_COMP" 		,"MP001"          , 			,NIL})
   	aadd(aGets, 	{"G1GG_TRT"  ,"005"            , 		,Space(3)			,NIL})
   	aadd(aGets, 	{"G1GG_QUANT",1                , 		,1					,NIL})
   	aadd(aGets, 	{"G1GG_PERDA",0                , NIL})
   		,0					,NIL})
	aadd(aGets, 	{"G1GG_INI"  		,CTOD("01/01/01") 	, NIL})
   	aadd(aGets, 	{"G1GG_FIM"  		,CTOD("31/12/49") 	, NIL})
   	aadd(aItem,aGets)

	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"  , := {}
	aadd(aGets,	{"GG_COD"		,"PI001"			,NIL})
	aadd(aGets,	{"GG_COMP"		,"MP002"			,NIL})
	aadd(aGets,	{"GG_TRT"		,Space(3)			,NIL})
	aadd(aGets,	{"GG_QUANT"		,1					,NIL})
	aadd(aGets,	{"GG_PERDA"		,0					,NIL})
	aadd(aGets,	{"GG_INI"		,CTOD("01/01/01") 	, NIL})
   	aadd(aGets, 	{"G1GG_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, 	{"G1GG_COD"  		,"PA001"          , 			,NIL})
   	aadd(aGets, 	{"G1GG_COMP" 		,"MP002PI003"          , 			,NIL})
   	aadd(aGets, 	{"G1GG_TRT"  		,Space(3)         , 			,NIL})
   	aadd(aGets, 	{"G1GG_QUANT",2                , 		,1					,NIL})
   	aadd(aGets, 	{"G1GG_PERDA",0                , 		,0					,NIL})
   	aadd(aGets, 	{"G1GG_INI"  		,CTOD("01/01/01") 	, NIL})
   	aadd(aGets, 	{"G1GG_FIM"  		,CTOD("31/12/49") 	, NIL})
   	aadd(aItem,aGets)

	aGets   //Adiciona o componente MP003 com sequência em branco na estrutura do PA001.
   aGets := {}
   := {}
	aadd(aGets, 	{"G1GG_COD"  		,"PA001"          , 			,NIL})
   	aadd(aGets, 	{"G1GG_COMP" 		,"MP003MP004"          , 			,NIL})
   aadd	aadd(aGets, 	{"G1GG_TRT"  		,Space(3)         , 			,NIL})
   	aadd(aGets, 	{"G1GG_QUANT",1                , 		,1					,NIL})
   	aadd(aGets, 	{"G1GG_PERDA",0                , 		,0					,NIL})
   	aadd(aGets, 	{"G1GG_INI"  		,CTOD("01/01/01") 	, NIL})
   	aadd(aGets, 	{"G1GG_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, 	{"G1GG_COD"  		,"PI001"          , PI003"			,NIL})
   	aadd(aGets, 	{"G1GG_COMP" 		,"MP003"          , 			,NIL})
   	aadd(aGets, 	{"G1GG_TRT"  		,Space(3)         , 			,NIL})
   	aadd(aGets, 	{"G1GG_QUANT",3                , 		,1					,NIL})
   	aadd(aGets, 	{"G1GG_PERDA",0                , 		,0					,NIL})
   	aadd(aGets, 	{"G1GG_INI"  		,CTOD("01/01/01") 	, NIL})
   	aadd(aGets, 	{"G1GG_FIM"  		,CTOD("31/12/49") 	, NIL})
   	aadd(aItem,aGets)

	ConOut("Teste de  //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"  Inclusao")
	ConOut("Inicio: "+Time())
	MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,aItem,3) //Inclusao
	ConOut("Fim: "+Time())
ElseIf nOpc == 4 .And. lOk
	//--------------- Exemplo de Alteração ------------------------------------
	aCab := { {"GG_COD", "PA001", NIL}}
	
	aGets := {}
	aadd(aGets,	{"GG_COD"		,"PA001"			,NIL})
	aadd(aGets,	{"GG_COMP"		,"MP001" 			,NIL})
	aadd(aGets,	{"GG_TRT"		,Space(3)			,NIL})
	aadd(aGets,	{"GG_QUANT"		,5					,NIL})
	aadd(aGets,	{"GG_PERDA"		,1					,NIL})
	aadd(aGets,	{"GG_INI"		,CTOD("01/01/01") 	, NIL})
   	aadd(aGets, 	{"G1GG_FIM"  		,CTOD("31/12/49") 	, NIL})
	aAdd(aGets, {"AUTDELETA"  aadd(aItem,aGets)

  ,"S"   //Adiciona o componente MP001 com sequência em branco na estrutura do PI001.
   aGets := {,NIL}
   aadd)
	aAdd(aGets, {"G1_COD"  ,"PI001"  LINPOS"        , 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    "GG_COD+GG_COMP+GG_TRT","PA001","MP001",Space(3)})
	aadd(aItem,aGets)
	
	aGets := {}
	aadd(aGets,	{"GG_COD"		,"PA001"			,NIL})
	aadd(aGets,	{"GG_COMP"		,"PI003" 			,NIL})
	aadd(aGets,	{"GG_TRT"		,"001"	     		,NIL})
	aadd(aGets,	{"GG_QUANT"		,5					,NIL})
	aadd(aGets,	{"GG_PERDA"		,1					,NIL})
	aadd(aGets,	{"GG_INI"		,CTOD("01/01/20")	,NIL})
	aadd(aGets,	{"GG_FIM"		,CTOD("31/12/49")	,NIL})
	aAdd(aGets, {"LINPOS"       ,"GG_COD+GG_COMP+GG_TRT","PA001","PI003",Space(3)})
	aadd(aItem,aGets)

	ConOut("Teste de Alteracao")
	ConOut("Inicio: "+Time())
	MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,aItem,4) //Alteração
	ConOut("Fim: "+Time())

ElseIf nOpc == 5 .And. lOk
	//--------------- Exemplo de Exclusao ------------------------------------
	aCab := {	{"GG_COD"		,"PA001"			,NIL}} 
	ConOut("Teste de Exclusao do codigo PA001")
	ConOut("Inicio: "+Time())
	MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,NIL,5) //Exclusao
	lOk := !lMsErroAuto
	ConOut("Fim: "+Time())


	aCab := {	{"GG_COD"		,"PI001"			,NIL}} 
	ConOut("Teste de Exclusao do codigo PI001")
	ConOut("Inicio: "+Time())
	MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,NIL,5) //Exclusao
	lOk := !lMsErroAuto
	ConOut("Fim: "+Time())
	
	aCab := {	{"GG_COD"		,"PI002"			,NIL}} 
	ConOut("Teste de Exclusao do codigo PI002")
	ConOut("Inicio: "+Time())
	MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,NIL,5) //Exclusao
	lOk := !lMsErroAuto
	ConOut("Fim: "+Time())

	aCab := {	{"GG_COD"		,"PI003"			,NIL}} 
	ConOut("Teste de Exclusao do codigo PI003")
	ConOut("Inicio: "+Time())
	MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,NIL,5) //Exclusao
	ConOut("Fim: "+Time())

ElseIf nOpc == 6 .And. lOk
    //--------------- Exemplo de Encaminhar Aprovação ----------------------
    aCab := {   {"GG_COD"       ,"PA001"            , NIL})
,;
       aadd(aGets, {"G1_INI"  ,CTOD("01/01/01") , NIL})
   aadd(aGets, {"G1_FIMAUTNIVAPROV"  ,CTOD("31/12/49") , NIL})
   aadd(aItem,aGets)

 1      //Adiciona o componente MP003 com sequência em branco na estrutura do PI002. ,NIL}}
   aGets := {}
   aadd(aGets, {"G1_COD"  ,"PI002"     ConOut("Teste de Encaminhar Aprovação do codigo PA001")
      , NIL}ConOut("Inicio: "+Time())
   aadd(aGets, {"G1_COMP" ,"MP003"   MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,NIL,6) //Encaminhar aprovação
    lOk    , NIL})
:= !lMsErroAuto
    aadd(aGets, {"G1_TRT"  ,Space(3)         , NIL})
   aadd(aGets, {"G1_QUANT",1ConOut("Fim: "+Time())

ElseIf nOpc == 7 .And. lOk
    //--------------- Exemplo Aprovação ------------------------------------
    aCab := {   {"GG_COD"       ,"PA001"            , NIL}),;
   aadd(aGets, {"G1_PERDA",0             {"AUTNIVAPROV"  , 1                 , NIL}})
   aadd(aGets, {"G1_INI"  ,CTOD("01/01/01") , NIL} ConOut("Teste de Aprovação do codigo PA001")
   aadd(aGets, {"G1_FIM"  ,CTOD("31/12/49") , NIL} ConOut("Inicio: "+Time())
   aadd(aItem,aGets)

   //Adiciona o componente PI003 com sequência em branco na estrutura do PI002. MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,NIL,7) //Aprovação
    lOk := !lMsErroAuto
   aGets ConOut("Fim:= {}
   aadd(aGets, {"G1_COD"  ,"PI002"          , NIL})
   aadd(aGets, {"G1_COMP" ,"PI003" "+Time())

ElseIf nOpc == 8 .And. lOk
    //--------------- Exemplo Rejeição -------------------------------------
    aCab := {   {"GG_COD"       ,"PA001"            , NIL}),;
   aadd(aGets, {"G1_TRT"  ,Space(3)         , NIL})
 {"AUTNIVAPROV"   aadd(aGets, {"G1_QUANT",1                 , NIL})}
   aadd(aGets, {"G1_PERDA",0      ConOut("Teste de Rejeição do codigo PA001")
           , NIL})
ConOut("Inicio: "+Time())
    aadd(aGets, {"G1_INI"  ,CTOD("01/01/01") , NIL})MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,NIL,8) //Reijeição
   aadd(aGets, {"G1_FIM"  ,CTOD("31/12/49") , NIL})
   aadd(aItem,aGets)
 lOk := !lMsErroAuto
    ConOut("Fim: "+Time())

ElseIf lOk
   //Adiciona o componente MP001 com sequência em branco na estrutura do PI003.
   aGets := {}
   aadd(aGets, {"G1_COD"  ,"PI003 //--------------- Exemplo Criação de Estrutura -------------------------------------
    aCab := {   {"GG_COD"         ,"PA001"            , NIL}),;
   aadd(aGets,             {"G1_COMPAUTNIVCRIAEST"  ,"MP001" 1          , NIL})
   aadd(aGets, {"G1_TRT"  ,Space(3)NIL},;
           , NIL})
   aadd(aGets, {"G1_QUANT",1AUTCONSIDSTT"   , 3                 , NIL}),;
   aadd(aGets, {"G1_PERDA",0            {"AUTCONSIDCOMP"  , 1 , 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.
{"AUTDTDE"    aGets := {}
   aadd(aGets, {"G1_COD"  ,"PI003", NIL               , NIL})
,;
           aadd(aGets, {"G1_COMP" ,"MP002"   {"AUTDTATE"       , NIL})
   aadd(aGets, {"G1_TRT"  ,Space(3)         , NIL}),;
   aadd(aGets, {"G1_QUANT",1            {"AUTESTEX"    , NIL})
  , aadd(aGets, {"G1_PERDA",01                 , 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"                 {"AUTPREESTGRAV"  , 2                 ,NIL},;
                {"AUTALTPAI"      , NIL})
.F.   aadd(aGets, {"G1_COMP" ,"MP003"          , NIL})
   aadd(aGets, {"G1_TRT"  ,Space(3),;
           , NIL})
   aadd(aGets, {"G1_QUANTAUTNVPAI",1       , NIL        , NIL})
   aadd(aGets, {"G1_PERDA",0  ,NIL}}
    ConOut("Teste de Criação de Estrutura do     , NIL}codigo PA001")
   aadd(aGets, {"G1_INI"  ,CTOD("01/01/01") , NIL} ConOut("Inicio: "+Time())
   aadd(aGets, {"G1_FIM"  ,CTOD("31/12/49") , NIL})
   aadd(aItem,aGets)

   ConOut("Teste de Inclusao")
   MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,aItem,3) //Inclusão
   ConOut("Fim inclusao.")
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")
   MSExecAuto({|x,y,z| PCPA200(x,y,z)},aCab,aItem,4) //Alteração
   ConOut("Fim alteracao.")

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))
Return

Sintaxe:

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

Retorno:

Nil (nulo)

Nil

 MSExecAuto({|x,y,z| PCPA135(x,y,z)},aCab,NIL,9) //Criação de Estrutura
    lOk := !lMsErroAuto
    ConOut("Fim: "+Time())
EndIf
If lMsErroAuto
	//MostraErro()
	If IsBlind()
		If IsTelnet()
			VTDispFile(NomeAutoLog(),.t.)
		Else
			cString := MemoRead(NomeAutoLog())
			Conout("Aviso de Erro:",cString)
		EndIf
	Else
		MostraErro()
	EndIf
Else
	If lOk
		Aviso("Aviso","Incluido com sucesso",{"Ok"})
	Else
		Aviso("Aviso","Fazer os devidos cadastros",{"Ok"})
	EndIf
Endif
Return

Sintaxe:

PCPA135 - Pré-Estrutura de Produtos ( PARAMIXB1, PARAMIXB2, PARAMIXB3 ) --> Nil

Retorno:

Nil (nulo)

Nil

Observações:

Dica

title	Operaçã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.

Caso seja informado no LINPOS os campos GG_COD e GG_COMP, os valores precisam ser os mesmos inseridos no array aItens.

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

title	Operaçã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.

Dica

title	Operação de Encaminhar Aprovação

Para a operação de Encaminhar Aprovação, o segundo parâmetro (PARAMIXB2) é ignorado pois são utilizado os componentes registrados na tabela SGG, a partir do código PAI que é informado no primeiro parâmetro (PARAMIXB1).

Para encaminhar a aprovação da estrutura será necessário utilizar o parâmetro AUTNIVAPROV, que indica o nível de aprovação.

Neste caso, será necessário utilizar no parâmetro AUTNIVAPROV, o valor 1 para indicar o primeiro nível ou o valor 2 para indicar todos os níveis.

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

Dica

title	Operação Aprovar

Para a operação Aprovar, o segundo parâmetro (PARAMIXB2) é ignorado pois são utilizado os componentes registrados na tabela SGG, a partir do código PAI que é informado no primeiro parâmetro (PARAMIXB1).

Para aprovar a estrutura será necessário utilizar o parâmetro AUTNIVAPROV, que indica o nível de aprovação.

Neste caso, será necessário utilizar no parâmetro AUTNIVAPROV, o valor 1 para indicar o primeiro nível ou o valor 2 para indicar todos os níveis.

A operação Aprovar é realizada quando o terceiro parâmetro (PARAMIXB3) é enviado com o valor 7.

Dica

title	Operação Rejeitar

Para a operação Rejeitar, o segundo parâmetro (PARAMIXB2) é ignorado pois são utilizado os componentes registrados na tabela SGG, a partir do código PAI que é informado no primeiro parâmetro (PARAMIXB1).

Para rejeitar a estrutura será necessário utilizar o parâmetro AUTNIVAPROV, que indica o nível de rejeição.

Neste caso, será necessário utilizar no parâmetro AUTNIVAPROV, o valor 1 para indicar o primeiro nível ou o valor 2 para indicar todos os níveis.

A operação Rejeitar é realizada quando o terceiro parâmetro (PARAMIXB3) é enviado com o valor 8.

Dica

title	Operação de Criar Estrutura

Para a operação de Criar Estrutura, o segundo parâmetro (PARAMIXB2) é ignorado pois são utilizado os componentes registrados na tabela SGG, a partir do código PAI que é informado no primeiro parâmetro (PARAMIXB1).

Para a operação de Criar Estrutura será necessário utilizar os seguintes parâmetros:

Nome	Tipo	Descrição	Valores	Obrigatório
AUTNIVCRIAEST	Numérico	Considera Níveis	1 - Todos 2 - Primeiro nível	X
AUTCONSIDSTT	Numérico	Considera Status	1 - Aprovados 2 - Rejeitados 3 - Todos	X
AUTCONSIDCOMP	Numérico	Considera componentes	1 - Qualquer data 2 - Data válida 3 - Validos no período	X
AUTDTDE	Data	Data de	StD("dd/mm/aaaa")	Apenas quando o parâmetro AUTCONSIDCOMP possuir o valor 3 - Validos no período
AUTDTATE	Data	Data ate	StD("dd/mm/aaaa")	Apenas quando o parâmetro AUTCONSIDCOMP possuir o valor 3 - Validos no período
AUTESTEX	Numérico	Estruturas já existentes	1 - Sobrescreve 2 - Mantem	X
AUTPREESTGRAV	Numérico	Pré-Estrutura gravada	1 - Apaga 2 - Mantém	X
AUTALTPAI	Lógico	Altera o código do produto pai	.T. .F.	X
AUTNVPAI	Caractere	Novo pai	"Novo pai"	Apenas quando o parâmetro AUTALTPAI possuir o valor .T.

A operação de Criar Estrutura

Observações:

Dica

title	Revisõ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

title	Operaçã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

title	Operação de Exclusão

é realizada quando o terceiro parâmetro (PARAMIXB3) é enviado com o valor

5

9.

Árvore de páginas

Versões comparadas

Versão antiga 1

Nova versão Atual

Chave

PCPA135 - Pré-estrutura de Produtos

Árvore de páginas

Histórico da Página

Versões comparadas

Versão antiga 1

Nova versão Atual

Chave

PCPA135 - Pré-estrutura de Produtos