Desenvolvimento Código Aberto

O Dicionário de dados ABAP permite que você defina tipos de dados e estruturas complexas que serão visíveis globalmente em um sistema SAP, entretanto o Dicionário ABAP possui alguns tipos de dados embutidos no sistema que são utilizados pelo próprio ambiente SAP.

Os tipos de dados de tabelas de banco de dados são um subconjunto de todos os tipos possíveis, ou seja, são chamadas de estruturas planas, sendo assim, os elementos de dados no Dicionário ABAP descrevem os campos individuais. Eles são as menores unidades indivisíveis de tipos complexos e são usados ​​para especificar os tipos de colunas no banco de dados. Atente-se que as classes e Interfaces não fazem parte do Dicionário ABAP, mas residem na biblioteca de classes (Class Library).

Tipos de dados Embutidos

Tipos de dados Built-in

Os elementos de dados do Dicionário ABAP podem ser herdados e manipulados de um modo bem simples, você pode utilizar campos unitários ou tabelas inteiras, e se você conhece o tipo de dados no qual quer trabalhar basta utilizar uma referencia ao campo e pronto. Visto que alguns tipos podem possuir uma formatação pré-definida, isto se deve ao fato de que todos os tipos de dados no Dicionário ABAP baseiam-se em elementos de dados, então todos eles contêm os atributos semânticos correspondentes, veja a tabela abaixo no qual os campos serão herdados em nosso programa de exemplo:

SFLIGHT – Elementos de Dados

Independente de você manipular ou não algum tipo de dado no banco de dados, uma vez que os elementos de dados são globais podemos herda-los e utiliza-los de qualquer modo, mesmo não fazendo muito sentido utilizar elementos de dados definidos em uma tabela transparente e não manipular seus dados, podemos ver que isto é totalmente possível. O modo como se utiliza elementos de dados no Dicionário ABAP é muito similar a instrução %TYPE encontrada no banco de Oracle, onde utiliza-se [NOME DA TABELA].[NOME DO CAMPO]%TYPE para obter o tipo de campo declarado em uma tabela sem se preocupar com sua definição.

Data Types ABAP Dictionary: http://help.sap.com/saphelp_46c/helpdata/en/cf/21f2e5446011d189700000e8322d00/content.htm

Abap Dictionary Types

Exemplo:

Neste exemplo utilizamos os elementos de dados do Dicionário ABAP de um modo muito similar a instrução %TYPE do banco de dados Oracle, no qual nos permite herdar campos de tabelas transparentes que utilizam tipos built-in do Dicionário ABAP sem nos preocupar com sua real definição de dados.

Abap

*&---------------------------------------------------------------------*
*& Report  ZABAPDIC
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Tipos do Dicionario Abap
*&---------------------------------------------------------------------*

REPORT  ZABAPDIC.

* Utiliza dados globais contidos na tabela SFLIGHT
* Os Tipos utilizados pertencem ao Dicionário de Dados Abap

DATA float TYPE sflight-PRICE.    " CURR 15,2
DATA char  TYPE SFLIGHT-CARRID.   " Char 3
DATA int   TYPE SFLIGHT-SEATSMAX. " INT4 10
DATA date  TYPE SFLIGHT-FLDATE.   " DATS

* Alimenta dados
float  = '10000.66'.
char   = '1A2'.
int    = '10000.66'.
date   = '20140918'.

* Imprime resultados
WRITE : / 'Tipos de Dados Globais do Dicionário Abap', /,
        / 'Numero flutuante ', float,
        / 'Caracteres ', char,
        / 'Numero inteiro ', int,
        / 'Data ', date.

Apesar do nome Data Objects não ter haver com a clássica programação orientada a objeto, os objetos de dados também fazem parte do ABAP OO, permitindo criar ou referenciar objetos de dados dentro de Objetos Abap, parece confuso não é? Mas é que o conceito de Data Objects antecede o conceito de Objetos Abap.

Os objetos de dados contêm os dados com os quais os programas ABAP trabalham em tempo de execução. Eles não são persistentes, mas apenas existem enquanto durar o programa. Antes que você possa processar dados persistentes, tais como dados de uma tabela de banco de dados ou de um arquivo sequencial, você deve primeiro lê-los em objetos de dados. Por outro lado, se você quiser manter o conteúdo de um objeto de dados para além do final do programa, você deve salvá-lo de uma forma persistente.

Nos já vimos vários objetos de dados ao longo dos posts na categoria Abap, agora vamos ver como utiliza-los de uma forma diferente, utilizando tipos de dados e tipos de Objeto de dados simultaneamente e fazendo interação complexas entre eles.

Dinamic Data Objects

Objetos de Dados

• Literais – são objetos de texto, que não são criados através da declaração DATA.
• Text Symbols – são ponteiros de textos criados através de literais, exemplo: ‘textoliteral'(###).
• Variables – são variáveis declaradas através das instruções: DATA, CLASS-DATA, STATICS, PARAMETERS, SELECT-OPTIONS e RANGES.
• Anonymous Data Objects – são objetos de dados declarados dinamicamente, utilizando a instrução CREATE DATA, que podem ser endereçados através de referencias.
• System-Defined Data Objects – são objetos de dados do sistema, que não precisam ser declarados e pois já existem em tempo de execução, exemplo: sy-subrc ou a referencia me-> dentro de métodos de classes.
• Interface Work Areas – são nomes especiais de objetos de dados que são utilizados para passar dados entre telas e programas Abap, porem estes são obsoletos e existem apenas a nível de compatibilidade.

Exemplo:

Neste exemplo utilizamos tipos de dados e objetos de dados, que são criados estaticamente e dinamicamente e utilizados através de referencias entre os vários Data Objects existentes no programa.

Abap

*&---------------------------------------------------------------------*
*& Report  ZOBJETODADOS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Objeto de dados
*&---------------------------------------------------------------------*

REPORT  ZOBJETODADOS.

* Para entender este exemplo
* primeiro você precisa saber como funciona
* os campos de símbolo em ABAP

TYPES:
  BEGIN OF estrutura,
    coluna1 TYPE c LENGTH 6,
    coluna2 TYPE c LENGTH 6,
  END OF estrutura.

DATA: referencia1 TYPE REF TO data,
      referencia2 TYPE REF TO data.

* declara campos de simbolo (ponteiros)
FIELD-SYMBOLS: <simbolo1> TYPE estrutura,
               <simbolo2> TYPE c.

* Cria uma variável de dados dinamicamente
CREATE DATA referencia1 TYPE estrutura.

* aponta referencia ao simbolo
ASSIGN referencia1->* TO <simbolo1>.

* Alimenta dados no simbolo
<simbolo1>-coluna1 = 'Dados1'.
<simbolo1>-coluna2 = 'Dados2'.

* Lembre-se referenciando o ponteiro você também
* faz referencia a variável ou vice-versa
referencia2 = referencia1.

ASSIGN referencia2->* TO <simbolo2> CASTING.
WRITE : / 'Imprime valores do Simbolo 2:',
        / <simbolo2>, /.

* O simbolo1 faz referencia ao objeto de dados dinâmico (referencia1)
* deste modo é possível recuperar sua referencia.
GET REFERENCE OF <simbolo1>-coluna2 INTO referencia2.

ASSIGN referencia2->* TO <simbolo2>.
WRITE : / 'Re-imprime valores do Simbolo 2:',
        / <simbolo2>.

Os Field Symbols são espaços reservados na memoria ou nomes simbólicos para outros campos. Eles não reservam um espaço físico para  os símbolos declarados, mas apontam para o seu conteúdo. Um Field Symbol pode apontar para qualquer objeto de dados.

Sempre que você endereçar um Field Symbol em um programa, você está endereçando o campo que é atribuído ao Field Symbol, deste modo não há mais diferença se você faz referência ao símbolo ou ao próprio campo. Campos de símbolo são similares aos ponteiros de referencia em C, que utilizam o caractere * (asterisco).

Abap – Field Symbol

Exemplo:

Neste exemplo criamos uma linha de dados contendo duas colunas, a primeira coluna possui o conteúdo “dados”, após criarmos o campo de símbolo, o endereçamos a linha de dados,  o utilizamos como um ponteiro para igualar o valor contido na primeira coluna para a coluna vazia e exibimos novamente a linha de dados, assim podemos ver que ao manipular o ponteiro do campo de símbolo também estamos manipulando a linha de dados.

Abap

*&---------------------------------------------------------------------*
*& Report  ZFIELDSYMBOL
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Field Symbols
*&---------------------------------------------------------------------*

REPORT  ZFIELDSYMBOL.

* Declara objeto de dados
DATA: BEGIN OF linha,
        inicio(5) TYPE c VALUE 'DADOS',
        fim(5) TYPE c ,
      END OF linha.

* imprime valor da linha
WRITE : / 'Conteudo da linha:'.
WRITE : / 'Inicio: ', linha-INICIO, ' Fim: ', linha-FIM.

* Cria simbolo
FIELD-SYMBOLS <f> LIKE linha.

* Cria ponteiros de referencia
ASSIGN linha TO <f>.

* Move referencia
* Veja que ao mover os pointeiros
* Movemos o conteudo da variavel
* Isto porque um Field Symbol funciona como um Placeholder
MOVE <f>-INICIO TO <f>-FIM.

* re-imprime valor da linha
skip 1.
WRITE: / 'Field Simbolo (Pointer) reorganizado:'.
WRITE : / 'Inicio: ', linha-INICIO, ' Fim: ', linha-FIM.

Como sabemos o servidor de apresentação do sistema SAP, possui varias funções que permitem comunicação com o servidor de aplicações, como por exemplo, importar e exportar arquivos do lado cliente, entre suas varias outras funções, o servidor de apresentação nos permite também executar programas externos.

WS_EXECUTE é um módulo de função padrão disponível nos sistemas R/3 da SAP, dependendo da versão e nível de release. Esta função é responsável por executar qualquer programa não SAP, por exemplo, um editor, uma calculadora ou qualquer outro programa de sua escolha. WS_EXECUTE executa um programa no servidor de apresentação, podendo também utilizar parâmetros comuns para se comunicar com o executável.

Contudo o sistema SAP possui grande quantidade de funções obsoletas que ainda funcionam por compatibilidade com versões de programas mais antigos, a função WS_EXECUTE é uma delas, você pode substituir esta função pela classe CL_GUI_FRONTEND_SERVICES.

Abaixo vamos criar um programa baseado na brincadeira Simon disse, neste caso nosso programa passara mensagens através de parâmetros para um executável criado em uma outra linguagem de programação, o executável receberá a mensagem e a exibira em seu formulário.

Para a versão mais recente deste procedimento utilize CL_GUI_FRONTEND_SERVICES: Serviços de Frontend SAP

Comunicando-se com um programa C# através de parâmetros

1 – Primeiro precisamos criar um programa C# utilizando a IDE Visual Studio. Arraste para o formulário dois componentes Label, um componente PictureBox, 2 Componentes Panel e um componente Richtextbox. A captura dos parâmetros será executada no evento SHOWN do formulário. Utilize a figura abaixo para modelar o design do seu programa:

Visual Studio – Design

2 – Crie um novo programa Abap e utilize o código abaixo. Entre com um ou mais parâmetros separados por espaço na caixa de texto do sistema SAP e pressione o botão executar na barra de tarefas. Dê permissão para o servidor de apresentação executar o programa:

Parâmetros – Abap

3 – Você receberá uma mensagem de acordo com o resultado apresentado pelo servidor de apresentação:

Resultado

4 – Pronto o programa C# será executado e receberá os parâmetros enviados que serão mostrados em uma caixa de texto. Visto que o ambiente do .NET Framework nos retorna um ARRAY contendo, primeiro o caminho e o nome do executável e sequencialmente todos os parâmetros enviados:

Programa C# – Parâmetros

Exemplo:

Neste exemplo escrevemos dois programas em linguagens de programação diferentes e conseguimos uma comunicação entre eles por meio de parâmetros, este simples exemplo nos mostra inúmeras possibilidades de comunicação entre um programa ABAP e programas externos sem utilizar as funções de RFC da SAP.

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace CsSap
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            // Recupera e exibi parâmetros enviados para o executavel
            string[] args = Environment.GetCommandLineArgs();
            richTextBox1.AppendText(string.Format("{0}", String.Join(", ", args)));      
           
            // TODO: Criar funcionalidades para os parâmetros recebidos.
        }

    }
}

Abap

Função WS_EXECUTE:

*&---------------------------------------------------------------------*
*& Report  ZSAPDISSE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& SAP Disse: WS_EXECUTE
*&---------------------------------------------------------------------*

REPORT  ZSAPDISSE.

* cria parametro para os parametros do executavel
PARAMETER SAPDISSE TYPE c LENGTH 70.

* declara variavel para o caminho do executavel
DATA programa TYPE string.

programa = 'C:\Desenvolvimento Aberto\temp\CsSap.exe'.

* Chama função que executa um executavel
CALL FUNCTION 'WS_EXECUTE'
  EXPORTING
    PROGRAM            = programa
    COMMANDLINE        = SAPDISSE
    INFORM             = ' '
  EXCEPTIONS
    FRONTEND_ERROR     = 1
    NO_BATCH           = 2
    PROG_NOT_FOUND     = 3
    ILLEGAL_OPTION     = 4
    GUI_REFUSE_EXECUTE = 5
    OTHERS             = 6.

* verifica estado da execução
CASE SY-SUBRC.
  WHEN 1.
    WRITE: / 'ERRO NO FRONTEND!'.
  WHEN 2.
    WRITE: / 'NO BATCH!'.
  WHEN 3.
    WRITE: / 'PROGRAMA NÃO ECONTRADO!'.
  WHEN 4.
    WRITE: / 'OPÇÃO ILEGAL!'.
  WHEN 5.
    WRITE: / 'SAP GUI SE RECUSOU A EXECUTAR O PROGRAMA!'.
  WHEN 6.
    WRITE: / 'OUTROS ERROS!'.
  WHEN OTHERS.
    WRITE: / 'PROGRAMA EXECUTADO COM SUCESSO!!!!'.
    MESSAGE 'Programa executado com sucesso!' TYPE 'S'.
ENDCASE.

Classe CL_GUI_FRONTEND_SERVICES:

*&---------------------------------------------------------------------*
*& Report  ZSAPDISSE_FES
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& CL_GUI_FRONTEND_SERVICES
*&---------------------------------------------------------------------*

REPORT  ZSAPDISSE_FES.

* cria parametro para os parametros do executavel
PARAMETER SAPDISSE TYPE string.

* declara variavel para o caminho do executavel
DATA programa TYPE string.

programa = 'C:\Desenvolvimento Aberto\temp\CsSap.exe'.

* Executa método de classe
CL_GUI_FRONTEND_SERVICES=>EXECUTE(
  exporting
    APPLICATION            =     programa
    PARAMETER              =     sapdisse
  exceptions
    CNTL_ERROR             = 1
    ERROR_NO_GUI           = 2
    BAD_PARAMETER          = 3
    FILE_NOT_FOUND         = 4
    PATH_NOT_FOUND         = 5
    FILE_EXTENSION_UNKNOWN = 6
    ERROR_EXECUTE_FAILED   = 7
    SYNCHRONOUS_FAILED     = 8
    NOT_SUPPORTED_BY_GUI   = 9
    OTHERS                 = 10 ).

* verifica estado da execução
CASE SY-SUBRC.
  WHEN 1.
    WRITE: / 'ERRO CNTL!'.
  WHEN 2.
    WRITE: / 'ERRO NO FRONTEND!!'.
  WHEN 3.
    WRITE: / 'ERRO NO PARAMETRO!'.
  WHEN 4.
    WRITE: / 'PROGRAMA NÃO ECONTRADO!'.
  WHEN 5.
    WRITE: / 'CAMINHO NÃO ECONTRADO!'.
  WHEN 6.
    WRITE: / 'EXTENSÃO DESCONHECIDA!'.
  WHEN 7.
    WRITE: / 'ERRO DE EXECUÇÃO!'.
  WHEN 8.
    WRITE: / 'FALHA NA SINCRONIZAÇÃO!'.
  WHEN 9.
    WRITE: / 'NÃO SUPORTADO PELO GUI!'.
  WHEN 10.
    WRITE: / 'OUTROS!'.
  WHEN OTHERS.
    WRITE: / 'PROGRAMA EXECUTADO COM SUCESSO!!!!'.
    MESSAGE 'Programa executado com sucesso!' TYPE 'S'.
ENDCASE.

Para ler dados a partir do servidor de apresentação para uma tabela interna usando um diálogo de usuário, use a função de Upload. Para ler dados a partir do servidor de apresentação para uma tabela interna sem o uso de uma caixa de diálogo do usuário, use a função WS_UPLOAD. Para mais informações, consulte a documentação do módulo de função (SE37).

Contudo o sistema SAP possui grande quantidade de funções obsoletas que ainda funcionam por compatibilidade com versões de programas mais antigos, a função Upload é uma delas, você pode substituir esta função pela função chamada GUI_UPLOAD.

GUI_UPLOAD: Função GUI_UPLOAD

Importando arquivo do Excel para uma tabela interna

1 – Para utilizar este exemplo, primeiro crie uma planilha comum com três colunas do tipo xls:

Open Office Calc

2 – Exporte a planilha para um arquivo texto separado por tabulações:

Texto – separados por tab

3 – Utilize o código abaixo para importar o arquivo para uma tabela interna:

Tabela Interna

Exemplo:

Neste exemplo importamos dados de um arquivo texto separado por tabs de uma planilha no formato xls.

Abap

Function : UPLOAD

*&---------------------------------------------------------------------*
*& Report  ZDATASERVER3
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Servidor de Apresentação - Upload
*&---------------------------------------------------------------------*

REPORT  ZDATASERVER3.

* Declara variaveis
DATA: FNOME(128), FTIPO(3), FTAMANHO TYPE I.

* Cria tabela
TYPES: BEGIN OF LINE,
  COL1(10) TYPE C,
  COL2(10) TYPE C,
  COL3(20) TYPE C,
END OF LINE.

* Cria e declara tabela interna
TYPES ITAB TYPE LINE OCCURS 10.
DATA: LIN TYPE LINE,
TAB TYPE ITAB.

* Chama a função de Upload
CALL FUNCTION 'UPLOAD'
  EXPORTING
    CODEPAGE            = 'IBM'
    FILENAME            = 'C:\Desenvolvimento Aberto\temp\Plan001.txt'
    FILETYPE            = 'DAT'
    ITEM                = 'Lê arquivo txt separado por tab exportado do Excel'
  IMPORTING
    FILESIZE            = FTAMANHO
    ACT_FILENAME        = FNOME
    ACT_FILETYPE        = FTIPO
  TABLES
    DATA_TAB            = TAB
  EXCEPTIONS
    CONVERSION_ERROR    = 1
    INVALID_TABLE_WIDTH = 2
    INVALID_TYPE        = 3.

* Imprime dados na tela
WRITE: 'SY-SUBRC:', SY-SUBRC,
/ 'Name :', (60) FNOME,
/ 'Type :', FTIPO,
/ 'Size :', FTAMANHO.

SKIP 2.

WRITE / 'Conteudo do Arquivo .TXT:'.

SKIP.

LOOP AT TAB INTO LIN.
  WRITE: / LIN-COL1, LIN-COL2 COLOR 4 INVERSE, LIN-COL3 COLOR 3 INVERSE.
ENDLOOP.

Function : GUI_UPLOAD

*&---------------------------------------------------------------------*
*& Report  ZDATASERVER4
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& GUI_UPLOAD
*&---------------------------------------------------------------------*

REPORT  ZDATASERVER4.

* Declara variaveis
DATA: FTAMANHO TYPE I.

* Cria tabela
TYPES: BEGIN OF LINE,
  COL1(10) TYPE C,
  COL2(10) TYPE C,
  COL3(20) TYPE C,
END OF LINE.

* Cria e declara tabela interna
TYPES ITAB TYPE LINE OCCURS 10.
DATA: LIN TYPE LINE,
TAB TYPE ITAB.

* Chama função GUI_UPLOAD
CALL FUNCTION 'GUI_UPLOAD'
  exporting
    FILENAME                = 'C:\Desenvolvimento Aberto\temp\Plan001.txt'
    FILETYPE                = 'DAT'
  importing
    FILELENGTH              = FTAMANHO
  tables
    DATA_TAB                = TAB
  exceptions
    FILE_OPEN_ERROR         = 1
    FILE_READ_ERROR         = 2
    INVALID_TYPE            = 3.

* Imprime dados na tela
WRITE: 'SY-SUBRC:', SY-SUBRC,
     / 'Size :', FTAMANHO.

SKIP 2.

WRITE / 'Conteudo do Arquivo .TXT:'.

SKIP.

LOOP AT TAB INTO LIN.
  WRITE: / LIN-COL1, LIN-COL2 COLOR 4 INVERSE, LIN-COL3 COLOR 3 INVERSE.
ENDLOOP.

Para gravar dados a partir de uma tabela interna para o servidor de apresentação usando um diálogo de usuário, use a função de Download. Para gravar dados de uma tabela interna para o servidor de apresentação sem o uso de uma caixa de diálogo do usuário, use a função WS_DOWNLOAD. Para mais informações, consulte a documentação do módulo de função (SE37).

Contudo o sistema SAP possui grande quantidade de funções obsoletas que ainda funcionam por compatibilidade com versões de programas mais antigos, a função Download é uma delas, você pode substituir esta função pela função chamada GUI_DOWNLOAD.

Exporta para XLS

GUI_DOWNLOAD: http://help.sap.com/saphelp_nw70ehp2/helpdata/de/c7/5ab8ec178c44a8aacd1dcac3460db8/content.htm

Exemplo:

Neste exemplo extraímos dados de uma tabela interna em um arquivo Excel e o salvamos no computador local.

Abap

Function : DOWNLOAD

*&---------------------------------------------------------------------*
*& Report  ZDATASERVER
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Escreve dados no servidor de apresentação
*&---------------------------------------------------------------------*

REPORT  ZDATASERVER.

* Declara Variáveis
DATA: FNOME(128), FTIPO(3), FTAMANHO TYPE I.

* Cria tabela com duas colunas
TYPES: BEGIN OF LINE,
  COL1 TYPE I,
  COL2 TYPE I,
END OF LINE.

* Cria Tabela temporaria
TYPES ITAB TYPE LINE OCCURS 15.
DATA: LIN  TYPE LINE, TAB TYPE ITAB.

* Cria e adiciona dados a tabela
DO 15 TIMES.
  LIN-COL1 = SY-INDEX.
  LIN-COL2 = SY-INDEX ** 2.
  APPEND LIN TO TAB.
ENDDO.

* Chama a função de download
* Dat cria tipo do Excel
CALL FUNCTION 'DOWNLOAD'
  EXPORTING
    CODEPAGE            = 'IBM'
    FILENAME            = 'C:\Desenvolvimento Aberto\temp\Planilha.xls'
    FILETYPE            = 'DAT'
    ITEM                = 'Teste Excel'
  IMPORTING
    ACT_FILENAME        = FNOME
    ACT_FILETYPE        = FTIPO
    FILESIZE            = FTAMANHO
  TABLES
    DATA_TAB            = TAB
  EXCEPTIONS
    INVALID_FILESIZE    = 1
    INVALID_TABLE_WIDTH = 2
    INVALID_TYPE        = 3.

* Imprime resultado
WRITE: 'SY-SUBRC:', SY-SUBRC,
     / 'Nome :', (60) FNOME,
     / 'Tipo :', FTIPO,
     / 'Tamanho :', FTAMANHO.

WRITE : / 'Conteudo do arquivo:', /.
LOOP AT tab INTO lin.
   WRITE : / LIN-COL1 COLOR 3 INVERSE,
             LIN-COL2 COLOR 3 INVERSE.
ENDLOOP.

Function : GUI_DOWNLOAD

*&---------------------------------------------------------------------*
*& Report  ZDATASERVER2
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& GUI_DOWNLOAD
*&---------------------------------------------------------------------*

REPORT  ZDATASERVER2.
* Declara Variáveis
DATA:  FTAMANHO TYPE I.

* Cria tabela com duas colunas
TYPES: BEGIN OF LINE,
  COL1 TYPE I,
  COL2 TYPE I,
END OF LINE.

* Cria Tabela temporaria
TYPES ITAB TYPE LINE OCCURS 15.
DATA: LIN  TYPE LINE, TAB TYPE ITAB.

* Cria e adiciona dados a tabela
DO 15 TIMES.
  LIN-COL1 = SY-INDEX.
  LIN-COL2 = SY-INDEX ** 2.
  APPEND LIN TO TAB.
ENDDO.

* Chama a função de download
* Dat cria tipo do Excel
CALL FUNCTION 'GUI_DOWNLOAD'
  EXPORTING
    FILENAME   = 'C:\Desenvolvimento Aberto\temp\Planilha2.xls'
    FILETYPE   = 'DAT'
  IMPORTING
    FILELENGTH = FTAMANHO
  TABLES
    DATA_TAB   = TAB.

* Imprime resultado
WRITE: 'SY-SUBRC:', SY-SUBRC,
     / 'Tamanho :', FTAMANHO.

WRITE : / 'Conteudo do arquivo:', /.
LOOP AT tab INTO lin.
  WRITE : / LIN-COL1 COLOR 3 INVERSE,
            LIN-COL2 COLOR 3 INVERSE.
ENDLOOP.

Programas Include permitem que você gerencie programas complexos de uma forma ordenada. Os grupos funcionais e módulo usam programas Include para armazenar as partes do programa que pertencem um ao outro. O ABAP Workbench o apoia extensivamente ao criar tais programas complexos, criando os programas Includes automaticamente, atribuindo-lhes nomes exclusivos.

Os Includes permitem que você use o mesmo código fonte em diferentes programas. Por exemplo, isso pode ser útil se você tiver declarações de dados longas que você deseja usar em programas diferentes. Você pode por exemplo utilizar programas Includes para criar uma biblioteca de classes locais, eventos PBO, eventos PAI, procedimentos Forms entre outros, ou quando você queira organizar melhor seu código fonte.

Entretanto os programas Includes possuem duas restrições:  programas Includes não podem chamar a si mesmo e devem conter declarações completas, deste modo não é possível separar em programas Includes a definição de uma classe de sua implementação em arquivos de código fonte diferentes, assim como é de boa pratica em C++, já que ABAP OO foi baseado nesta linguagem, principalmente explicitando deste modo a separação da sintaxe entre a definição de uma classe e a implementação. Mas deveria, certo?

Tipo I – Programa Include

Os Includes são programas do tipo I – são um meio de dividir o código do programa em unidades menores e mais manejáveis. É possível inserir a codificação de um programa Include, em qualquer ponto de outro programa ABAP usando a instrução Include. Não há nenhuma relação técnica entre programas Includes e blocos de processamento. Includes são mais adequados para as unidades de programação lógicas, tais como declarações de dados ou conjuntos de blocos de processamento similares.

Exemplo:

Neste exemplo criamos um programa ABAP comum chamado ZMEUINCLUDE e um programa do tipo I, chamado ZINC_DEF, onde o programa include contem uma classe e o programa principal chama seu método estaticamente.

Abap

Programa – Principal

*&---------------------------------------------------------------------*
*& Report  ZMEUINCLUDE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Include - Modularization Techniques
*&---------------------------------------------------------------------*

REPORT  ZMEUINCLUDE.

* Chama o programa include
INCLUDE ZINC_DEF.

START-OF-SELECTION.
* Instancia estatica do objeto
HELLO=>OLA( ).

Programa – Include

*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*&---------------------------------------------------------------------*
*& Include: ZINC_DEF
*&---------------------------------------------------------------------*

* Definição da classe
CLASS hello DEFINITION.

  PUBLIC SECTION.

    CLASS-METHODS Ola.

ENDCLASS.

* Implementação da classe
CLASS hello IMPLEMENTATION.

  METHOD ola.
    Write  'Hello World Include'.
  ENDMETHOD.

ENDCLASS.

Se você precisa programar uma aplicação extensiva, um único programa pode se tornar muito complexo. Para tornar o programa mais fácil de ler, muitas vezes é razoável dividir as funções necessárias entre vários programas. Programas ABAP, como grupos de funções, também podem se conectar com outros programas ABAP e podem se comunicar de varias maneiras diferentes.

A instrução Submit permite que você possa especificar o nome do programa que você deseja chamar estaticamente, digitando o nome do programa no código do programa de chamada, ou dinamicamente, especificando o nome de um campo (entre parênteses) que contém o nome do programa. Se o sistema não encontrar o programa executável especificado ao tentar executar a instrução, ocorre um erro de execução.

O Submit possui a instrução complementar chamada And Return que permite retornar ao programa que o chamou, deste modo o sistema armazena os dados do programa executável chamado e retorna para a chamada após o processamento do programa chamado. O sistema retoma a execução do programa de chamada para a declaração após a chamada.

Submit

Uma observação interessante neste ponto é que cada vez que você executa um programa executável, uma declaração SUBMIT ocorre. Quando você digita o nome do programa em uma transação como SE38 e SA38 e escolhe Executar, uma declaração Submit ocorre na transação. É, portanto, um atributo técnico de um programa do tipo 1 que são chamados usando a instrução Submit, embora sua principal característica do ponto de vista de um usuário é que eles são iniciados em primeiro plano.

Exemplo:

Neste exemplo criamos dois programas, o ZPROG1 e ZPROG2, onde o programa 1 chama e alimenta parâmetros para o programa 2 e assim que o programa 2 é fechado, a execução do programa 1 é automaticamente retomada.

Abap

Programa – 1

*&---------------------------------------------------------------------*
*& Report  ZPROG1
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Programa 1 - Call Program
*&---------------------------------------------------------------------*

REPORT  ZPROG1.

Write : / 'Eu sou o programa 1'.

* Chama e transfere dados
SUBMIT ZPROG2 VIA SELECTION-SCREEN
              WITH v1 eq 'Desenvolvimento'
              WITH v2 eq 'Aberto' AND RETURN.

SKIP 2.

FORMAT HOTSPOT COLOR 3 INVERSE ON.
Write : / 'Você retornou para o programa 1'.

Programa – 2

*&---------------------------------------------------------------------*
*& Report  ZPROG2
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Programa 2 - Call Program
*&---------------------------------------------------------------------*

REPORT  ZPROG2.

PARAMETER : v1(15) TYPE c,
            v2(15) TYPE c.

START-OF-SELECTION.

WRITE : 'Eu sou o Programa 2 e recebi duas variáveis', /,
      / 'Variável 1 = ', v1,
      / 'Variável 2 = ', v2.

SKIP.

FORMAT HOTSPOT COLOR 6 INVERSE ON.
WRITE : / 'Clique no botão Voltar e em Fechar para retornar ao programa 1'.

Cada função no sistema SAP tem um código de transação associado. Um código de transação consiste em letras, números, ou ambos. Você pode entrar com um código de transação no campo de comando quando desejar ir para qualquer tarefa em um aplicativo SAP mais rápido. Ao entrar um código de transação em vez de usar o menu, você vai para uma tarefa e começa a função em uma única etapa.

Podemos dizer que Transaction Codes ou Tcodes são como atalhos em um sistema SAP, você pode digita-los e acessar diretamente o conteúdo que você necessita, como programas entre outros tipos de transações, você também pode criar um código de transação para executar seus programas.

Mais informações sobre Tcodes: Maintaining Transactions e Working with Transaction Codes

Criando um código de transação para seu programa

1 – Primeiro precisamos criar um programa para ser executado pelo nosso tcode, entre na transação SE38 e digite o código abaixo, logo após criar, testar e ativar o programa, entre na transação SE93 e digite para nosso Tcode o seguinte código: ZDA1

SE93 – Maintaining Transactions

2 – Após a criar o Tcode você precisa escolher o tipo de transação desejada, existem vários tipos, escolha a opção Program and Selection Screen:

Create Transaction

3 – Preencha os detalhes da sua transação, como o pacote que será inserida, descrição, autorização, o tipo de suporte para o SAP GUI e o nome do programa que você deseja executar, em nosso caso ZTCODE:

Change Report Transaction

4 – Após salvar sua transação, digite /n para voltar para a tela inicial do sistema e digite, ZDA1 no campo do Tcode e aperte a tecla Enter:

SAP Easy Access

5 – Então seu programa será executado com sucesso:

ZDA1 – Programa

Exemplo:

Neste exemplo criamos um programa chamado ZTCODE e o associamos a uma transação de nome ZDA1.

Abap

*&---------------------------------------------------------------------*
*& Report  ZTCODE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Minha primeira transação - Tcode
*&---------------------------------------------------------------------*

REPORT  ZTCODE.

Write : / 'Hello World - Tcode', /.
skip 2.
Write at 50 :  'ZDA1 - transação para este programa' color 2.

Você pode utilizar as funções NMIN e NMAX para retornar os valores mínimos e máximos entre pelo menos dois parâmetros. Estas funções fazem o mesmo trabalho da clausula IF efetuando comparações utilizando os sinais de maior (>) ou menor (<), porem possuem uma sintaxe muito menos complexa se utilizados muitos parâmetros.

Fora de uma expressão aritmética, um tipo de cálculo é determinado a partir de todos os argumentos, e é utilizado para realizar a comparação. O tipo de cálculo é determinado apenas como uma expressão aritmética e também determina o tipo do valor de retorno de dados.

Em uma expressão aritmética, os argumentos da função contribuem para o tipo de cálculo de toda a expressão e a função é calculada usando o tipo do cálculo. Se um argumento em si é uma expressão aritmética, os operandos contribuem para todo o tipo de cálculo e o argumento também é calculado usando esse mesmo tipo.

Funções – Extremum

Exemplo:

Neste exemplo criamos uma tela de seleção com três parâmetros e as funções Extremum verificam e exibem uma mensagem retornando o maior e o menor parâmetro dentro das possibilidades alimentadas pelo usuário.

Abap

*&---------------------------------------------------------------------*
*& Report  ZMAXMIN
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Numerical Extremum Functions
*&---------------------------------------------------------------------*

REPORT  ZMAXMIN.

* Cria parametros de seleção
SELECTION-SCREEN COMMENT /1(10) text-par.
PARAMETERS: valor1 TYPE i DEFAULT 0,
            valor2 TYPE i DEFAULT 0,
            valor3 TYPE i DEFAULT 0.

* Declara variáveis
DATA:   minimo    TYPE decfloat34,
        maximo    TYPE decfloat34,
        val1      TYPE decfloat34,
        val2      TYPE decfloat34,
        val3      TYPE decfloat34,
        txt       TYPE string.

* Inicio da seleção
START-OF-SELECTION.

* Verifica os valores minimos e máximos
minimo =  nmin( val1 = valor1 val2 = valor2 val3 = valor3 ).
maximo =  nmax( val1 = valor1 val2 = valor2 val3 = valor3 ).

* Cria texto da menssagem
 txt = |{ txt } o valor minimo é: { minimo } e o valor máximo é: { maximo } |.

* Exibe menssagem de informação
 MESSAGE txt TYPE 'I'.

* Exibe menssagem de erro (valida campos)
AT SELECTION-SCREEN.
  IF valor1 = 0 or valor2 = 0 or valor3 = 0.
    MESSAGE 'Você deve entrar com um valor diferente de zero' TYPE 'E'.
  ENDIF.