ER_MANMAT01-900_integracao_contrato_trade_easy_logix

(Obrigatório)

Informações Gerais

   Legenda: 1 – Inovação 2 – Manutenção (Os demais campos devem ser preenchidos para ambos os processos). 

(Obrigatório)

Objetivo

Permitir que seja integrado no Trade-Easy, as ordens de compras via SUP4330/SUP22104, provenientes de contrato fechado com Fornecedor estrangeiro. Desta forma apenas ordens de compra que passaram pelo split, e seus itens possuirem contrato de fornecimento fechado com fornecedor estrangeiro, deverão ser enviados para Trade-Easy incluir o pedido de compra, sem a necessidade de enviar a ordem de compra pelo SUP34093. Assim a cotação será considerada de acordo com  o percentual de participação realizado no contrato fechado.

<Nesta etapa informar o objetivo da especificação do requisito, ou seja, o que a funcionalidade deve fazer. Exemplo: Permitir que o usuário defina o percentual mínimo em espécie (dinheiro), a referência mínima para calculo dos débitos do aluno e o período de validade do parâmetro de negociação>.

(Obrigatório)

Definição da Regra de Negócio

           Será previsto nos programas SUP4330/SUP22104 de elaboração dos pedidos de compra, para que sejam enviadas as ordens de compra que possuirem fornecedor e número de cotação, “contrato”, e que estejam com a situação Aberto para a Trade.

 Apenas ordens de compra que possuírem contrato fechado serão enviadas para Trade pelo SUP4330/SUP22104, as demais ordens de compra serão processadas normalmente gerando pedido de compra no ambiente Logix.

           Todo relatório referente a geração de pedidos com contratos será de responsabilidade da Trade.

            Todo processamento e regras anteriores a rotina do SUP4330/SUP22104 será mantido conforme já existente, permitindo alteração e exclusão, exceto a partir do momento que é processado as ordens de compra com contrato pelo SUP4330/SUP22104.

           Sendo assim as ordens que passam por aprovação eletrônica de compras, tanto por aprovação técnica de débito direto quanto as por nível de alçada , debito direto e estoque, terão suas manutenções mantidas pois ocorrem antes do processamento da geração do pedido, e conforme definição do projeto não sofreram mudanças nessa especificação,  será mantido que apenas ordens que tenham a situação em Aberto, que serão enviadas.

            As ordens de compras a serem enviadas pelo SUP4330/SUP22104,  não irão gravar pedido, apenas será utilizado o processamento com as consistências pertinentes a regras de negócios já existentes.

             Todas as ordens de compra enviadas pelo SUP4330/SUP22104 irão gravar registro na tabela sup_par_oc,” Ordem integrada ao Trade Easy”, parâmetro “integrado_trade_easy”, para que não sejam processadas novamente.

             Todas as ordens de compra com contrato enviadas, irão gravar registro na tabela sup_par_oc, com  informações do agrupador, e mesmo não tendo recebido a mensagem de order, (pedido) essas ordens de compra não serão mais permitidas que sofram alteração.

             Todas as ordens que tiverem o pedido gerado na Trade, irão retornar através da adapter EAIADAPTERORDER que chama a  Lib SUP10033. Lembrando que o SUP10033, realiza as consistências relacionadas a geração de pedidos, conforme definido no projeto original de integração Logix Trade.

              As ordens de compra serão enviadas através de mensagem única EAIADAPTERREQUEST1 no modo Sincrono, conforme definição original do projeto, terá apenas um retorno de mensagem recebida. Essa definição já é do escopo do projeto original e visa atender  funcionabilidades já acertadas com a Trade.

            Não existirá obrigatoriedade do cadastro das classificações fiscais (NCM),  cadastro de item  das ordens de compra, pois isso será tratado na Trade ao gerar os pedidos de compra.

            Conforme definição acertada com a Trade será enviada informações adicionais necessárias para que eles gerem os pedidos e nos retornem , através das Tag ADDFIELD_field e ADDFIELD_value, conforme descrito na tabela do adapter de envio da mensagem Request. (Tabela 01).

            As informações transitadas nessas tags, serão a de fornecedor, moeda, contrato, agrupador e como teremos o número do pedido temporário que seria gerado, mas não será gravado, iremos enviar para montar o relacionamento das ordens de compra que será realizado internamente na Trade.

             Lembrar que o número de pedido enviado, será apenas como referência para Trade e poderá não ser o mesmo utilizado após o recebimento do pedido via LIB SUP10033.

              O número oficial relacionado ao pedido é gerado somente no recebimento do adapter EAIADAPTERORDER (pedido de compra) via lib SUP10033 pelo Logix, enviado para Trade, para que eles possam fazer as consistências no sistema deles.

              Todo pedido recebido da Trade, estará com a situação como “R” , realizado de acordo com a definição original do projeto. (L_MAT001_IRM000254_REQ05_pedidos.)

               Não existira opção para reaproveitamento de pedidos, conforme existe no Logix.

               Os pedidos criados pela Trade e recebidos pelo Logix, via integração poderão ser consultados via programa SUP1582

               Toda ordem de compra que for processada e enviada para trade, irá gerar registro de consistência no relatório do SUP4330/SUP22104, com a informação de “Enviadas para Trade-Easy”.

               Todo o processamento de ordem de compra irá usar como Agrupador a data hora e minuto e segundo, para efeito de processamento, bem como o número do pedido Logix a ser recebido apenas como referência para a ordem de compra na TRADE.

               O Agrupador deverá agrupar as ordens de compra que obtiverem as mesmas condições comerciais e fornecedor para enviar para a Trade, isso significa que essas ordens deverão pertencer ao mesmo pedido de compra. Importante, não poderá conter no mesmo pedido de compras, ordens com condições comerciais e fornecedores diferentes. Sendo as consistências as condições comerciais também tratadas no Trade-Easy para garantir a integridade das informações.

                Todas as ordens de compra que já tiveram  pedido de compra gerado na Trade, não poderão sofrer alteração de de valores no ERP, esse processo terá que ser realizado no sistema da Trade, que nos enviará através do EAIADAPTERORDER, lib SUP10033 mensagem com variável indicando que se trata de uma atualização. Com isso as informações de valores deverão ser atualizadas no ERP.

                 Essa situação já é prevista no projeto original da Trade – Easy, conforme os requisitos, L_MAT001_IRM0000254_REQ03_Ordem_compra  e L_MAT001_IRM000254_REQ05_pedidos.

Definição dos Procedimentos

                 Usuário cria as ordens de compra (OCs) no Logix com os programas SUP0290/SUP0300 versão 10.02 ou SUP21003 versão 12

                Ao executar a rotina de geração de pedidos no Logix  SUP4330 versão 10.02 ou SUP22104 versão 12, especificamente para os pedidos de contrato, caso o parâmetro “integra_tradeimport” indique que o Logix está integrado com Trade-Easy Importação,  serão enviadas mensagens Request,  afim de criar as Solicitações de Importação (SI’s) no Trade-Easy conforme diagrama entidade relacionamento;

a.      Cada Ordem de compra que seria atendida pelo contrato gerará uma mensagem Request a ser enviada ao Trade-Easy, gerando uma SI (cada Ordem de compra terá um registro na tabela SUP_PAR_OC , parâmetro "integrado_trade_easy", indicando este envio para a Trade-Easy, conforme já é realizado no envio de Ordem de compras pelo SUP34093);

b.      Além das tags que compõem uma mensagem Request tradicional, serão enviadas informações que estariam no pedido automático do Logix (ex.: fornecedor, moeda, número do contrato, data/hora/minuto/segundo, número de pedido temporário), visando agrupar as Ordens de compra que comporiam o Pedido de Compra no Logix e alimentar a tela facilitadora que gerará o Purchase Order (PO) e, posteriormente, enviará o Pedido de Compra ao Logix;

c.       Nesta situação , os pedidos automáticos não serão gerados pelo SUP4330/SUP22104  no Logix, mas somente após o envio pelo Trade-Easy;

           Trade-Easy disponibilizará uma tela facilitadora, não disponível no ERP Logix, para agrupar as SI’s que serão atendidas pelo contrato (com base nas informações enviadas pelo Logix), onde o usuário de Comex complementará as informações específicas da importação (ex.: INCOTERM, via de transporte, etc.) e gerará o PO;

            É retomado fluxo tradicional da integração, onde a mensagem Order é enviada ao Logix para criação do Pedido de Compra, sendo enviada via o adapter EAIADAPTERORDER e processada pelo SUP10033, responsável por incluir e gerar o número do pedido que será enviado para Trade;

             O uso das funcionalidades disponíveis no Easy Import Control anteriores a geração do Purchase Order, como a cotação de preços, serão mantidos para os itens que não possuem contrato.

<Na tabela abaixo informe quais são as rotinas envolvidas, o tipo de operação, a opção de menu e se necessário uma breve descrição das regras de negócio relacionadas a rotina>.

Exemplo de Aplicação:

• Alteração no adapter de envio da mensagem Request para as tags que identificam as Ordens de Compra que teriam o pedido gerado automaticamente pelo Logix (fornecedor, número do contrato, etc.)

Iremos passar pela tag otther fields os seguintes campos e os valores, não será previsto a parte de contrato de serviços, SISCOSERV

- Fornecedor

- Moeda

- Número do Contrato

- Número pedido Logix.

- Agrupador

Na Lib SUP10032 prever o uso das variáveis  passando como parâmetro “FORNECEDOR”, “MOEDA” , “CONTRATO” e "AGRUPADOR", lembrar que o campo  condição de pagamento já existe no adapter, mais não esta ajustado, para uso. Fazer a chamada da função EAIHelperRequest1_set_BusinessContent_PaymentConditionCode, passando a condição de pagamento.

Tabela de variáveis do adapter EAIADAPTERREQUEST1 com registros enviados para TRADE-EASY

A função SUP10032, será responsável por setar as variáveis da ordem compra, a serem enviadas pelo trade-Easy

O adapter EAIADAPTERREQUEST1, terá que ser alterado para prever o uso dos campos já existentes no HELPER, que ainda não foram setados os valores.

Lembrando que não haverá necessidade de alteração da estrutura do XSD, uma vez que será utilizado os campos já existentes.

Segue abaixo “modelo” de upsert utilizado para a integração de ordem de compra e que deverá ser adequado para fazer a integração da request:

        IF find4glfunction("EAIAdapterRequest1_SendBusinessMessage") THEN

           IF SUP10032_ordem_integrada_portal() THEN

              CALL EAIMapper_Clear()

              CALL EAIMapper_set("ordem_sup.cod_empresa", p_ordem_sup.cod_empresa)

              CALL EAIMapper_set("ordem_sup.num_oc", p_ordem_sup.num_oc)

              CALL EAIMapper_set("ordem_sup.gru_ctr_desp", p_ordem_sup.gru_ctr_desp)

              CALL EAIMapper_set("ordem_sup.cod_item", p_ordem_sup.cod_item)

              CALL EAIMapper_set("ordem_sup.pre_unit_oc", p_ordem_sup.pre_unit_oc)

              CALL EAIMapper_set("ordem_sup.dat_entrega_prev", p_ordem_sup.dat_entrega_prev)

              CALL EAIMapper_set("ordem_sup.cod_secao_receb", p_ordem_sup.cod_secao_receb)

              CALL EAIMapper_set("ordem_sup.cod_unid_med", p_ordem_sup.cod_unid_med)

              CALL EAIMapper_set("ordem_sup.qtd_solic", p_ordem_sup.qtd_solic)

              CALL EAIMapper_set("ordem_sup.cnd_pgto", p_ordem_sup.cnd_pgto)

              CALL EAIMapper_set("ordem_sup.fornecedor", p_ordem_sup. fornecedor)

              CALL EAIMapper_set("ordem_sup.moeda", p_ordem_sup.moeda)

              #Num contação é o número de contrato

              CALL EAIMapper_set("ordem_sup.num_contacao", p_ordem_sup. num_contacao)

              IF NOT EAIAdapterRequest1_SendBusinessMessage("upsert") THEN

                 CALL log0030_mensagem("Problemas durante a integração com Trade. " || EAIMapper_getError(1), "exclamation")

                 LET l_status = FALSE

              END IF

           END IF

        END IF

Caberá ao programa TradeEasy, ao receber um XML  gerar o pedido com base no número de contrato, campo ADDFIELD_field = “CONTRATO”, “FORNECEDOR”,  “MOEDA” , “AGRUPADOR” e “PEDIDOLOGIX”

Se houver necessidade de envio de novas informações será utilizada as tags de  ADDFIELD_field e ADDFIELD_value , bem como a validação da viabilidade da regra de negócios para os novos dados ( necessidade de construir funções para atender os valores solicitados nos novos campos, ocorrendo essa situação será necessário verificar a demanda de tempo envolvida.)

Alterações nas rotinas dos programas de envio.

#------------------------------------------------------------------------------------------------#

 FUNCTION sup10033_verifica_ordem(lr_ordem_sup, l_funcmsgorder)

#-------------------------------------------------------------------------------------------------#

 DEFINE l_parametro        LIKE sup_par_oc.parametro_ind

 DEFINE lr_ordem_sup       RECORD LIKE ordem_sup.*

 DEFINE l_funcmsgorder     CHAR(03)

 WHENEVER ERROR CONTINUE

  SELECT sup_par_oc.parametro_ind

    INTO l_parametro

    FROM sup_par_oc

   WHERE sup_par_oc.empresa       = lr_ordem_sup.cod_empresa

     AND sup_par_oc.ordem_compra  = lr_ordem_sup.num_oc

     AND sup_par_oc.parametro     = "integrado_trade_easy"

     AND sup_par_oc.seq_parametro = 1

 WHENEVER ERROR STOP

 IF sqlca.sqlcode <> 0 THEN

    RETURN FALSE, "Ordem de compra não integrada ao Trade Easy"

 END IF

 IF l_parametro <> "S" THEN

    RETURN FALSE, "Ordem de compra não integrada ao Trade Easy"

 END IF

 IF l_funcmsgorder = 9 THEN   # Faz verificações apenas se o processo for de inclusão

    IF lr_ordem_sup.ies_situa_oc <> "A" THEN   #Verifica se ordem está aberta

          RETURN FALSE, "Ordem de compra não está com situação aberta."

     END IF  

 END IF

    IF lr_ordem_sup.num_pedido <> 0 THEN       #Verifica se a ordem ainda não possui pedido

       RETURN FALSE, "Ordem de compra já possui pedido associado. "

    END IF

 END IF

 RETURN TRUE, " "

END FUNCTION

##############################

#------------------------------------------------#

 FUNCTION sup10032_exporta_ordem_compra_contrato()

#------------------------------------------------#

 DEFINE l_ind,l_status      SMALLINT,

        l_msg               CHAR(150)

 DEFINE l_data              DATETIME YEAR TO SECOND

 LET l_data = EXTEND(CURRENT, YEAR TO SECOND)

 FOR l_ind = 1 TO 3000

     CALL sup10032_set_other_addfields_addfield_field("FORNECEDOR",1)

     CALL sup10032_set_other_addfields_addfield_value(ma_ordem_sup[l_ind].cod_fornecedor,1)

     CALL sup10032_set_other_addfields_addfield_field("MOEDA",2)

     CALL sup10032_set_other_addfields_addfield_value(ma_ordem_sup[l_ind].cod_moeda,2)

     CALL sup10032_set_other_addfields_addfield_field("CONTRATO",3)

     CALL sup10032_set_other_addfields_addfield_value(ma_ordem_sup[l_ind].num_cotacao,3)

     CALL sup10032_set_other_addfields_addfield_field("AGRUPADOR",4)

     CALL sup10032_set_other_addfields_addfield_value(l_data,4)

     CALL sup10032_set_other_addfields_addfield_field("PEDIDOLOGIX",5)

     CALL sup10032_set_other_addfields_addfield_value(ma_ordem_sup[l_ind].num_pedido,5)

     CALL EAIMapper_set("ordem_sup.cod_empresa"      ,   ma_ordem_sup[l_ind].cod_empresa)

     CALL EAIMapper_set("ordem_sup.num_oc"           ,   ma_ordem_sup[l_ind].num_oc)

     CALL EAIMapper_set("ordem_sup.cod_item"         ,   ma_ordem_sup[l_ind].cod_item)

     CALL EAIMapper_set("ordem_sup.pre_unit_oc"      ,   ma_ordem_sup[l_ind].pre_unit_oc)

     CALL EAIMapper_set("ordem_sup.dat_entrega_prev" ,   ma_ordem_sup[l_ind].dat_entrega_prev)

     CALL EAIMapper_set("ordem_sup.cod_secao_receb"  ,   ma_ordem_sup[l_ind].cod_secao_receb)

     CALL EAIMapper_set("ordem_sup.cod_unid_med"     ,   ma_ordem_sup[l_ind].cod_unid_med)

     CALL EAIMapper_set("ordem_sup.qtd_solic"        ,   ma_ordem_sup[l_ind].qtd_solic)

     CALL EAIMapper_set("ordem_sup.dat_entrega_prev" ,   ma_ordem_sup[l_ind].dat_entrega_prev)

     CALL EAIMapper_set("ordem_sup.cnd_pgto"         ,   ma_ordem_sup[l_ind].cnd_pgto)

     CALL EAIMapper_set("ordem_sup.num_cotacao"      ,   ma_ordem_sup[l_ind].num_cotacao)

     CALL EAIMapper_set("ordem_sup.cod_comprador"    ,   ma_ordem_sup[l_ind].cod_comprador)

     CALL EAIMapper_set("ordem_sup.pct_ipi"          ,   ma_ordem_sup[l_ind].pct_ipi)

     CALL EAIMapper_set("ordem_sup.gru_ctr_desp"     ,   ma_ordem_sup[l_ind].gru_ctr_desp)

     CALL EAIAdapterRequest1_SendBusinessMessage("upsert")

          RETURNING l_status

     IF NOT l_status THEN

        LET l_msg = 'Ordem de Compra: ',ma_ordem_sup[l_ind].num_oc CLIPPED,' - Erro ao enviar mensagem para o Adapter "EAIAdapterRequest1".'

        CALL log0030_mensagem(l_msg,"info")

        RETURN l_status

     END IF

 END FOR

 RETURN TRUE

END FUNCTION

#-------------------------------------------------------------------------#

 FUNCTION sup10032_set_other_addfields_addfield_field(l_conteudo, l_ind)

#-------------------------------------------------------------------------#

 DEFINE l_ind      SMALLINT

 DEFINE l_conteudo varchar(12)

 CALL EAIHelperRequest1_set_BusinessContent_ListOfRequestItem_RequestItem_OTHER_ADDFIELDS_ADDFIELD_field(l_conteudo, l_ind)

 END FUNCTION

#-------------------------------------------------------------------------#

 FUNCTION sup10032_set_other_addfields_addfield_value(l_conteudo, l_ind)

#-------------------------------------------------------------------------#

 DEFINE l_ind      SMALLINT

 DEFINE l_conteudo varchar(60)

 CALL EAIHelperRequest1_set_BusinessContent_ListOfRequestItem_RequestItem_OTHER_ADDFIELDS_ADDFIELD_value(l_conteudo, l_ind)

 END FUNCTION

#----------------------------------------------------------------#

 FUNCTION sup10032_inclui_oc_integrada(l_cod_empresa, l_num_oc)

#----------------------------------------------------------------#

 DEFINE l_cod_empresa    LIKE ordem_sup.cod_empresa,

        l_num_oc         LIKE ordem_sup.num_oc

 WHENEVER ERROR CONTINUE

 INSERT INTO sup_par_oc (empresa, ordem_compra, parametro, des_parametro, seq_parametro, parametro_ind)

      VALUES (l_cod_empresa, l_num_oc, 'integrado_trade_easy','Ordem integrada ao Trade Easy',1,'S')

 WHENEVER ERROR STOP

 IF sqlca.sqlcode = 0 THEN

    RETURN TRUE

 END IF

 RETURN TRUE

 END FUNCTION

#--------------------------------------------------------------#

 FUNCTION sup10032_set_all_ordem_sup(lr_ordem_sup,l_ind)

#--------------------------------------------------------------#

 DEFINE lr_ordem_sup        RECORD LIKE ordem_sup.*

 DEFINE l_ind               SMALLINT

  let ma_ordem_sup[l_ind].cod_empresa        = lr_ordem_sup.cod_empresa

  let ma_ordem_sup[l_ind].num_oc             = lr_ordem_sup.num_oc

  let ma_ordem_sup[l_ind].num_versao         = lr_ordem_sup.num_versao

  let ma_ordem_sup[l_ind].num_versao_pedido  = lr_ordem_sup.num_versao_pedido

  let ma_ordem_sup[l_ind].ies_versao_atual   = lr_ordem_sup.ies_versao_atual

  let ma_ordem_sup[l_ind].cod_item           = lr_ordem_sup.cod_item

  let ma_ordem_sup[l_ind].num_pedido         = lr_ordem_sup.num_pedido

  let ma_ordem_sup[l_ind].ies_situa_oc       = lr_ordem_sup.ies_situa_oc

  let ma_ordem_sup[l_ind].ies_origem_oc      = lr_ordem_sup.ies_origem_oc

  let ma_ordem_sup[l_ind].ies_item_estoq     = lr_ordem_sup.ies_item_estoq

  let ma_ordem_sup[l_ind].ies_imobilizado    = lr_ordem_sup.ies_imobilizado

  let ma_ordem_sup[l_ind].cod_unid_med       = lr_ordem_sup.cod_unid_med

  let ma_ordem_sup[l_ind].dat_emis           = lr_ordem_sup.dat_emis

  let ma_ordem_sup[l_ind].qtd_solic          = lr_ordem_sup.qtd_solic

  let ma_ordem_sup[l_ind].dat_entrega_prev   = lr_ordem_sup.dat_entrega_prev

  let ma_ordem_sup[l_ind].fat_conver_unid    = lr_ordem_sup.fat_conver_unid

  let ma_ordem_sup[l_ind].qtd_recebida       = lr_ordem_sup.qtd_recebida

  let ma_ordem_sup[l_ind].pre_unit_oc        = lr_ordem_sup.pre_unit_oc

  let ma_ordem_sup[l_ind].dat_ref_cotacao    = lr_ordem_sup.dat_ref_cotacao

  let ma_ordem_sup[l_ind].ies_tip_cotacao    = lr_ordem_sup.ies_tip_cotacao

  let ma_ordem_sup[l_ind].pct_ipi            = lr_ordem_sup.pct_ipi

  let ma_ordem_sup[l_ind].cod_moeda          = lr_ordem_sup.cod_moeda

  let ma_ordem_sup[l_ind].cod_fornecedor     = lr_ordem_sup.cod_fornecedor

  let ma_ordem_sup[l_ind].num_cotacao        = lr_ordem_sup.num_cotacao

  let ma_ordem_sup[l_ind].cnd_pgto           = lr_ordem_sup.cnd_pgto

  let ma_ordem_sup[l_ind].cod_mod_embar      = lr_ordem_sup.cod_mod_embar

  let ma_ordem_sup[l_ind].num_docum          = lr_ordem_sup.num_docum

  let ma_ordem_sup[l_ind].gru_ctr_desp       = lr_ordem_sup.gru_ctr_desp

  let ma_ordem_sup[l_ind].cod_secao_receb    = lr_ordem_sup.cod_secao_receb

  let ma_ordem_sup[l_ind].cod_progr          = lr_ordem_sup.cod_progr

  let ma_ordem_sup[l_ind].cod_comprador      = lr_ordem_sup.cod_comprador

  let ma_ordem_sup[l_ind].pct_aceite_dif     = lr_ordem_sup.pct_aceite_dif

  let ma_ordem_sup[l_ind].ies_tip_entrega    = lr_ordem_sup.ies_tip_entrega

  let ma_ordem_sup[l_ind].ies_liquida_oc     = lr_ordem_sup.ies_liquida_oc

  let ma_ordem_sup[l_ind].dat_abertura_oc    = lr_ordem_sup.dat_abertura_oc

  let ma_ordem_sup[l_ind].num_oc_origem      = lr_ordem_sup.num_oc_origem

  let ma_ordem_sup[l_ind].qtd_origem         = lr_ordem_sup.qtd_origem

  let ma_ordem_sup[l_ind].dat_origem         = lr_ordem_sup.dat_origem

  let ma_ordem_sup[l_ind].ies_tip_incid_ipi  = lr_ordem_sup.ies_tip_incid_ipi

  let ma_ordem_sup[l_ind].ies_tip_incid_icms = lr_ordem_sup.ies_tip_incid_icm

  let ma_ordem_sup[l_ind].cod_fiscal         = lr_ordem_sup.cod_fiscal

  let ma_ordem_sup[l_ind].cod_tip_despesa    = lr_ordem_sup.cod_tip_despesa

  let ma_ordem_sup[l_ind].ies_insp_recebto   = lr_ordem_sup.ies_insp_recebto

  let ma_ordem_sup[l_ind].ies_tipo_inspecao  = lr_ordem_sup.ies_tipo_inspecao

END FUNCTION

#--------------------------------------------------------------#

 FUNCTION sup10032_grava_oc_integrada_contrato(lr_ordem_sup)

#--------------------------------------------------------------#

 #Por existir processo transacional, uso de tabelas temp, iram comprometer o funcionamento da função

 #tratada com array, para enviar mensagem de request1 ao final do processo.

 DEFINE lr_ordem_sup     RECORD LIKE ordem_sup.*

 DEFINE l_ind            SMALLINT

 FOR l_ind = 1 TO 3000

     IF ma_ordem_sup[l_ind].cod_empresa IS NULL

        OR ma_ordem_sup[l_ind].cod_empresa = " " THEN

        CALL sup10032_set_all_ordem_sup(lr_ordem_sup.*,l_ind)

        CALL sup10032_grava_consistencia_oc(lr_ordem_sup.*,l_ind)

        EXIT FOR

     END IF

 END FOR

 END FUNCTION

#--------------------------------------------------------------#

 FUNCTION  sup10032_grava_consistencia_oc(lr_ordem_sup,l_ind)

#--------------------------------------------------------------#

 DEFINE lr_ordem_sup     RECORD LIKE ordem_sup.*

 DEFINE l_ind            SMALLINT

  WHENEVER ERROR CONTINUE

  CALL log085_transacao("BEGIN")

  WHENEVER ERROR STOP

  IF NOT sup10032_inclui_oc_integrada(lr_ordem_sup.cod_empresa, lr_ordem_sup.num_oc) THEN

     WHENEVER ERROR CONTINUE

     CALL log085_transacao("ROLLBACK")

     WHENEVER ERROR STOP

     RETURN

  END IF

  WHENEVER ERROR CONTINUE

  CALL log085_transacao("COMMIT")

  WHENEVER ERROR STOP

 END FUNCTION

#--------------------------------------------------------------#

 FUNCTION sup10032_verifica_oc_integrada_fornecedor_estrangeiro(lr_ordem_sup)

#--------------------------------------------------------------#

 DEFINE lr_ordem_sup      RECORD LIKE ordem_sup.*

 WHENEVER ERROR CONTINUE

 SELECT UNIQUE cod_fornecedor

  FROM fornecedor

 WHERE cod_fornecedor = lr_ordem_sup.cod_fornecedor

  AND cod_pais <>  '001'

 WHENEVER ERROR STOP

  IF sqlca.sqlcode <> 0 THEN

     IF sqlca.sqlcode <> 100 THEN

        CALL log003_err_sql("SELECT 2","fornecedor")

        RETURN FALSE

     END IF

     RETURN TRUE

  END IF

  RETURN TRUE

 END FUNCTION

#--------------------------------------------------------------#

 FUNCTION  sup10032_verifica_oc_integrada_contrato(lr_ordem_sup)

#---------------------------------------------------------------#

 #Verifica se a ordem de compra que será integrada tem contrato, se verdadeiro será enviada via request

  DEFINE lr_ordem_sup      RECORD LIKE ordem_sup.*

   IF NOT sup10032_verifica_oc_integrada_fornecedor_estrangeiro(lr_ordem_sup.*) THEN

      RETURN FALSE

    END IF

  IF  lr_ordem_sup.num_cotacao       > 0 AND lr_ordem_sup.pre_unit_oc > 0

      AND lr_ordem_sup.cod_moeda     > 0 AND lr_ordem_sup.cnd_pgto    > 0

      AND lr_ordem_sup.cod_mod_embar > 0 THEN

      RETURN TRUE

  ELSE

     IF (lr_ordem_sup.pre_unit_oc      IS NULL OR lr_ordem_sup.pre_unit_oc   = 0)

        OR (lr_ordem_sup.cod_moeda     IS NULL OR lr_ordem_sup.cod_moeda     = 0)

        OR (lr_ordem_sup.cnd_pgto      IS NULL OR lr_ordem_sup.cnd_pgto      = 0)

        OR (lr_ordem_sup.cod_mod_embar IS NULL OR lr_ordem_sup.cod_mod_embar = 0) THEN

        RETURN FALSE

     ELSE

        RETURN TRUE

     END IF

  END IF

  RETURN TRUE

 END FUNCTION

#----------------------------------------------------------------#

 FUNCTION sup10032_verifica_oc_integrada(l_cod_empresa, l_num_oc)

#----------------------------------------------------------------#

#Verifica se a ordem de compra, já foi enviada via mensagem unica request para Trade.

DEFINE l_cod_empresa    LIKE ordem_sup.cod_empresa,

       l_num_oc         LIKE ordem_sup.num_oc

  # condicoes para selecao das ordens de remessa de consignacao

  IF NOT m_flag THEN

     INITIALIZE m_emit_ped_consig TO NULL

     SELECT par_ies INTO m_emit_ped_consig

       FROM par_sup_pad

      WHERE par_sup_pad.cod_empresa   = p_cod_empresa

        AND par_sup_pad.cod_parametro = "emit_ped_consig"

     IF sqlca.sqlcode <> 0 OR m_emit_ped_consig IS NULL OR m_emit_ped_consig = " " THEN

        LET m_emit_ped_consig = "N"

     END IF

     LET m_flag = TRUE

  END IF

 WHENEVER ERROR CONTINUE

 SELECT UNIQUE empresa

   FROM sup_par_oc

  WHERE empresa       = l_cod_empresa

    AND ordem_compra  = l_num_oc

    AND parametro     = 'integrado_trade_easy'

    AND parametro_ind = 'S'

 WHENEVER ERROR STOP

 IF sqlca.sqlcode = 0 THEN

    RETURN TRUE

 END IF

 RETURN FALSE

 END FUNCTION

SUP4330

     # Verificar se a ordem de compra possui integração com o processo de importação TradeEasy

     IF find4GLFunction('sup10032_verifica_oc_integrada') THEN

        #IF sup10033_verifica_oc_integrado_TradeEasy(p_ordem_sup_orig.cod_empresa, p_ordem_sup_orig.num_oc) THEN

         IF sup10032_verifica_oc_integrada(p_ordem_sup_orig.cod_empresa, p_ordem_sup_orig.num_oc) THEN

           WHENEVER ERROR CONTINUE

           FETCH cq_ordem_sup1 INTO p_ordem_sup_orig.*

           WHENEVER ERROR STOP

           IF sqlca.sqlcode <> 0 THEN

              EXIT WHILE

           END IF

           CONTINUE WHILE

        END IF

     END IF

     IF p_processa = FALSE THEN

        WHENEVER ERROR CONTINUE

        CALL log085_transacao("ROLLBACK")

        WHENEVER ERROR STOP

     ELSE

        #Aqui tratado para integração com trade, tendo contrato, não ira permitir gerar o pedido, mas

        #manterar a consistencia para continuar processamento de outras ordens de compra e outros pedidos

        IF find4GLFunction('sup10032_verifica_oc_integrada_contrato') THEN

           IF sup10032_verifica_oc_integrada_contrato(p_ordem_sup_orig.*) THEN

              WHENEVER ERROR CONTINUE

              CALL log085_transacao("ROLLBACK")

              WHENEVER ERROR STOP

              CALL sup10032_grava_oc_integrada_contrato(p_ordem_sup_orig.*)

              LET p_processa       = FALSE

              LET p_erros.des_erro = "Enviadas para Trade-Easy. "

              CALL sup433_grava_excessoes(p_ordem_sup_orig.*)

              WHENEVER ERROR CONTINUE

              FETCH cq_ordem_sup1 INTO p_ordem_sup_orig.*

              WHENEVER ERROR STOP

              IF sqlca.sqlcode <> 0 THEN

                 EXIT WHILE

              END IF

              CONTINUE WHILE

           END IF

        END IF

     # Verificar se a ordem de compra possui integração com o processo de importação TradeEasy

     IF find4GLFunction('sup10032_verifica_oc_integrada') THEN

        #IF sup10033_verifica_oc_integrado_TradeEasy(p_ordem_sup_orig.cod_empresa, p_ordem_sup_orig.num_oc) THEN

         IF sup10032_verifica_oc_integrada(p_ordem_sup_orig.cod_empresa, p_ordem_sup_orig.num_oc) THEN

           WHENEVER ERROR CONTINUE

           FETCH cq_ordem_sup2 INTO p_ordem_sup_orig.*

           WHENEVER ERROR STOP

           IF sqlca.sqlcode <> 0 THEN

              EXIT WHILE

           END IF

           CONTINUE WHILE

        END IF

     END IF

     IF p_processa = FALSE THEN

        WHENEVER ERROR CONTINUE

        CALL log085_transacao("ROLLBACK")

        WHENEVER ERROR STOP

     ELSE

        #Aqui tratado para integração com trade, tendo contrato, não ira permitir gerar o pedido, mas

        #manterar a consistencia para continuar processamento de outras ordens de compra e outros pedidos

        IF find4GLFunction('sup10032_verifica_oc_integrada_contrato') THEN

           IF sup10032_verifica_oc_integrada_contrato(p_ordem_sup_orig.*) THEN

              WHENEVER ERROR CONTINUE

              CALL log085_transacao("ROLLBACK")

              WHENEVER ERROR STOP

              CALL sup10032_grava_oc_integrada_contrato(p_ordem_sup_orig.*)

              LET p_processa       = FALSE

              LET p_erros.des_erro = "Enviadas para Trade-Easy. "

              CALL sup433_grava_excessoes(p_ordem_sup_orig.*)

              WHENEVER ERROR CONTINUE

              FETCH cq_ordem_sup2 INTO p_ordem_sup_orig.*

              WHENEVER ERROR STOP

              IF sqlca.sqlcode <> 0 THEN

                 EXIT WHILE

              END IF

              CONTINUE WHILE

           END IF

        END IF

     # Verificar se a ordem de compra possui integração com o processo de importação TradeEasy

     IF find4GLFunction('sup10032_verifica_oc_integrada') THEN

        #IF sup10033_verifica_oc_integrado_TradeEasy(p_ordem_sup_orig.cod_empresa, p_ordem_sup_orig.num_oc) THEN

         IF sup10032_verifica_oc_integrada(p_ordem_sup_orig.cod_empresa, p_ordem_sup_orig.num_oc) THEN

           WHENEVER ERROR CONTINUE

           FETCH cq_ordem_sup3 INTO p_ordem_sup_orig.*

           WHENEVER ERROR STOP

           IF sqlca.sqlcode <> 0 THEN

              EXIT WHILE

           END IF

           CONTINUE WHILE

        END IF

     END IF

     IF p_processa = FALSE THEN

        WHENEVER ERROR CONTINUE

        CALL log085_transacao("ROLLBACK")

        WHENEVER ERROR STOP

     ELSE

        #Aqui tratado para integração com trade, tendo contrato, não ira permitir gerar o pedido, mas

        #manterar a consistencia para continuar processamento de outras ordens de compra e outros pedidos

        IF find4GLFunction('sup10032_verifica_oc_integrada_contrato') THEN

           IF sup10032_verifica_oc_integrada_contrato(p_ordem_sup_orig.*) THEN

              WHENEVER ERROR CONTINUE

              CALL log085_transacao("ROLLBACK")

              WHENEVER ERROR STOP

              CALL sup10032_grava_oc_integrada_contrato(p_ordem_sup_orig.*)

              LET p_processa       = FALSE

              LET p_erros.des_erro = "Enviadas para Trade-Easy. "

              CALL sup433_grava_excessoes(p_ordem_sup_orig.*)

              WHENEVER ERROR CONTINUE

              FETCH cq_ordem_sup3 INTO p_ordem_sup_orig.*

              WHENEVER ERROR STOP

              IF sqlca.sqlcode <> 0 THEN

                 EXIT WHILE

              END IF

              CONTINUE WHILE

           END IF

        END IF

IF find4GLFunction('sup10032_exporta_ordem_compra_contrato') THEN

     IF NOT sup10032_exporta_ordem_compra_contrato() THEN

     END IF

 END IF

• Alteração na rotina de geração automática de pedidos para Ordens de Compra atendidas por contrato, visando o envio para o Trade-Easy das ordens que comporiam o pedido automático (via mensagem Request, criando solicitações de importação no Trade-Easy), suspensão destas ordens (com motivo "Enviadas para Trade-Easy") e desvio para não gerar o pedido no Logix neste momento.

Conforme definição do projeto, todas as alterações anteriores ao envio do SUP4330/SUP22104 serão mantidas conforme projeto original.

Durante o processamento do programa SUP4330\SUP22104, as ordens que tiverem o fornecedor, e o número de contrato gerado, serão consideradas no processo de geração automática de pedidos do SUP4330\SUP22104.

A partir do momento que o programa SUP4330\SUP22104 envia as ordens para gerar os pedidos de compra, e incluído na tabela sup_par_oc, identificado as ordens que já foram enviadas, com isso   programa SUP34093 não irá processar novamente essas ordens.

Incluir busca para parâmetro

       Alterar na chamada de função do sup4330, para prever nas duas chamadas para trade Easy a funções abaixo.

     # Verificar se a ordem de compra possui integração com o processo de importação TradeEasy

     IF find4GLFunction('sup10033_verifica_oc_integrado_TradeEasy') THEN

        IF sup10033_verifica_oc_integrado_TradeEasy(p_ordem_sup_orig.cod_empresa, p_ordem_sup_orig.num_oc) THEN

           LET p_processa = TRUE

           WHENEVER ERROR CONTINUE

           FETCH cq_ordem_sup2 INTO p_ordem_sup_orig.*

           WHENEVER ERROR STOP

           IF sqlca.sqlcode <> 0 THEN

              EXIT WHILE

           END IF

           CONTINUE WHILE

        END IF

     END IF

Opcional

Protótipo de Tela

Imagem 01

Imagem 02

Imagem 03

Imagem 04

Imagem 05

<Caso necessário inclua protótipos de telas com o objetivo de facilitar o entendimento do requisito, apresentar conceitos e funcionalidades do software>.

Fluxograma das atividades

     Diagrama de Entidade e Relacionamento 

     Diagrama de Sequência