En las ultimas instalaciones del SAP GUI un componente para ver la representación grafica del formulario (SAP SCRIPT) fue removida por SAP, lo que causa un error al hacer click en el boton Layout en la transacción SE71.
El error es:
Graphical Form Painter could not be called (FORMPAINTER_CREATE_WINDOW, )
Para solucionar este error hay que bajar un archivo desde la pagina de soporte de SAP ( https://launchpad.support.sap.com/#/softwarecenter ), desde ahí buscamos SAPSLTESP00_0-70001053.EXE y nos mostrara algo como
Una vez bajado simplemente lo instalamos (Hay que cerrar completamente el SAP GUI) y ya podremos ver la representación grafica del formulario (SAP SCRIPT).
Hacemos click en Rotulación de etiquetas y agregamos una nueva entrada:
Volvemos a la SPRO y vamos a:
Creamos una nueva implementación:
Implementamos el método CHECK_ADD_ON_ACTIVE:
Volvemos a la SPRO:
Creamos una nueva implementación:
Creamos el filtro:
Creamos un grupo de función y le creamos una DynPro (La que especificamos anteriormente)
En la dynpro Agregamos el campo que queremos mostrar:
Implementamos el método GET_TAXI_SCREEN de la BADI:
En este punto ya podríamos ir a la transacción XD01 / 02 / 03 y ver nuestro campo.
Ahora hay que agregar una APPEND STRUCTURE a la tabla KNA1.
Ahora hay que hacer que en modo visualización el campo aparezca no editable, para esto vamos al grupo de función que creamos y agregamos el siguiente código:
Ahora debemos agregar la lógica para cargar y guardar el dato de nuestro campo Z.
Cargar:
Guardar:
Implementamos el método de la BADI (La de la subscreen).
Al igual que cuando creamos la vista CDS, para crear una table function debemos crear un data definition como hicimos antes, pero al momento de llegar al template seleccionamos “Define Table Function with parameters”
Al hacer click en finish nos aparecerá el template seleccionado el cual debemos completar para que quede similar a lo siguiente:
@EndUserText.label: 'Table function para vuelos'
define table function ZTF_VUELOS
with parameters
@Environment.systemField: #CLIENT
client : mandt,
returns {
client : abap.clnt;
carrid : s_carr_id;
connid : s_conn_id;
fldate : s_date;
carrname : s_carrname;
URL : s_carrurl;
price : s_price;
currency : s_currcode;
passname : s_passname;
}
implemented by method zcl_vuelos2=>obtener_datos_pasajeros;
Vemos que al final le estamos especificando la clase (ZCL_VUELOS2) y el método (obtener_datos_pasajeros) que vamos a llamar.
El próximo paso será crear esta clase y método, para esto hacemos click derecho sobre nuestro package o objeto local y seleccionamos crear una clase.
Ingresamos un nombre (El que usamos en la Table function) y descripción.
De nuevo seleccionamos una orden de transporte y le damos click a Finish o si es un objeto local directamente hacemos click en finish.
Nos creara el template que se vera similar a:
Adaptamos la clase para que tenga la lógica que nosotros queramos, por ejemplo:
CLASS zcl_vuelos2 DEFINITION
PUBLIC
FINAL
CREATE PUBLIC .
PUBLIC SECTION.
INTERFACES : if_amdp_marker_hdb.
CLASS-METHODS : obtener_datos_pasajeros FOR TABLE FUNCTION ZTF_VUELOS.
PROTECTED SECTION.
PRIVATE SECTION.
ENDCLASS.
CLASS zcl_vuelos2 IMPLEMENTATION.
METHOD obtener_datos_pasajeros BY DATABASE FUNCTION FOR HDB
LANGUAGE SQLSCRIPT
OPTIONS READ-ONLY
USING scarr sflight sbook.
RETURN
SELECT a.mandt AS client, a.carrid AS carrid, a.connid AS connid, a.fldate AS fldate,
b.carrname AS carrname, b.URL as URL, a.price AS price, a.currency AS currency,
c.passname AS passname FROM sflight AS a
INNER JOIN scarr AS b
ON a.carrid = b.carrid
INNER JOIN sbook AS c
ON a.carrid = c.carrid AND
a.connid = c.connid AND
a.fldate = c.fldate
WHERE a.mandt = c.mandt;
ENDMETHOD.
ENDCLASS.
Ahora debemos creamos una vista CDS que utilice nuestra table function. Para esto, como hicimos antes nos creamos una vista CDS.
Nuestra vista debería ser algo similar a esto:
Lo importante a ver acá, es que estamos haciendo el SELECT desde la Table Function (SELECT FROM ZTF_VUELOS ).
@AbapCatalog.sqlViewName: 'ZCDS_TF_DATOS_V'
@AbapCatalog.compiler.compareFilter: true
@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Datos de pasajeros usando TF'
define view ZCDS_TF_DATOS as select from ZTF_VUELOS ( client : $session.client ) {
carrid,
connid,
fldate,
carrname,
URL,
@Semantics.amount.currencyCode: 'CurrencyCode'
price,
@Semantics.currencyCode
cast ('USD' as abap.cuky) as CurrencyCode,
currency,
passname
}
Una ves con nuestra nueva vista creada, la podemos consultar como hicimos antes desde la SE16. Pero también lo que podemos hacer es ponerle un breakpoint en la clase que creamos.
Para hacer esto, en eclipse, vamos a la clase que creamos y hacemos doble click donde esta marcado en la captura de abajo. Nos debería aparecer un puntito en color verde si el breakpoint esta activo.
Una ves con el breakpoint activo, podemos ejecutar la vista desde la SE16 y se nos debería activar el debugger en eclipse.
Para ver mejor por debug podemos cambiar el código por:
CLASS zcl_vuelos2 DEFINITION
PUBLIC
FINAL
CREATE PUBLIC .
PUBLIC SECTION.
INTERFACES : if_amdp_marker_hdb.
CLASS-METHODS : obtener_datos_pasajeros FOR TABLE FUNCTION ZTF_VUELOS.
PROTECTED SECTION.
PRIVATE SECTION.
ENDCLASS.
CLASS zcl_vuelos2 IMPLEMENTATION.
METHOD obtener_datos_pasajeros BY DATABASE FUNCTION FOR HDB
LANGUAGE SQLSCRIPT
OPTIONS READ-ONLY
USING scarr sflight sbook.
/* RETURN */
lt_datos = SELECT a.mandt AS client, a.carrid AS carrid, a.connid AS connid, a.fldate AS fldate,
b.carrname AS carrname, b.URL as URL, a.price AS price, a.currency AS currency,
c.passname AS passname FROM sflight AS a
INNER JOIN scarr AS b
ON a.carrid = b.carrid
INNER JOIN sbook AS c
ON a.carrid = c.carrid AND
a.connid = c.connid AND
a.fldate = c.fldate
WHERE a.mandt = c.mandt;
RETURN :lt_datos;
ENDMETHOD.
ENDCLASS.
En la imagen de abajo podemos ver el breakpoint en la línea 22, a la derecha del código podemos ver nuestra variable lt_datos donde se guarda el resultado de la consulta y en la parte de inferior de la pantalla podemos ver el contenido de la tabla interna.
Tambien al igual que con una vista CDS común, la podemos usar desde un reporte ABAP:
SELECT * FROM ZCDS_TF_DATOS( pcarrid = 'AA', pconnid = '0017', pfldate = @lv_fecha )
INTO TABLE @DATA(lt_datos2).
IF sy-subrc = 0.
ENDIF.
Tambien podemos usar un ALV IDA para mostrar los datos:
REPORT zida_cds.
data: lo_exc type ref to cx_salv_function_not_supported.
try.
cl_salv_gui_table_ida=>create_for_cds_view( 'ZCDS_VUELOS' )->fullscreen( )->display( ).
catch cx_salv_function_not_supported into lo_exc.
message lo_exc type 'I'.
endtry.
En este post rápido, les voy a mostrar como crear una vista CDS fácilmente.
Ingresamos a Eclipse, vamos al package que usemos o creamos un Data Definition como objeto local.
En la ventana que se abre, buscamos Core Data Services y seleccionamos Data Definition.
Ingresamos un nombre / Descripción y hacemos click en next.
En la siguiente pantalla, se nos dará la opción de elegir una orden de transporte, en el caso que estemos trabajando en un package, si estamos en un objeto local nos aparecerá la pantalla griseada.
Seleccionamos la orden de transporte y hacemos click en next.
Si estamos en un objeto local hacemos click en next.
En la siguiente pantalla se nos dará a seleccionar un template para la vista CDS, seleccionamos Define View y hacemos click en Finish.
Al hacer click en Finish volveremos a Eclipse y veremos algo como lo siguiente:
En esta pantalla, debemos ingresar un nombre para nuestra vista ABAP (sqlViewName) y reemplazar el data_source_name por las tablas de donde sacamos los datos. Por ejemplo:
@AbapCatalog.sqlViewName: 'ZCDS_VUELOS_V'
@AbapCatalog.compiler.compareFilter: true
@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'CDS Para aerolineas y vuelos'
define view ZCDS_VUELOS as select from scarr
join sflight
on scarr.carrid = sflight.carrid
join sbook
on sflight.carrid = sbook.carrid and
sflight.connid = sbook.connid and
sflight.fldate = sbook.fldate
{
key scarr.carrid,
key sflight.connid,
key sflight.fldate,
key sbook.bookid,
scarr.carrname,
scarr.url,
sflight.price,
sflight.currency,
sflight.planetype,
sflight.seatsmax,
sflight.seatsocc,
sbook.customid,
sbook.custtype,
sbook.class,
sbook.loccuram,
sbook.loccurkey,
sbook.order_date,
sbook.passname
}
En esta vista CDS podemos ver que estamos haciendo un JOIN de 3 tablas.
Una ves que tenemos nuestra vista CDS lista, activamos (CTRL+F3).
Con nuestra vista CDS ya activa podemos ir a la SE16 con el nombre, en este caso ZCDS_VUELOS_V y probarla.
Vemos que nos trae datos:
También la podemos probar desde eclipse, haciendo click derecho sobre nuestra vista CDS y yendo a:
Tambien podemos hacer uso de la vista CDS desde un reporte de ABAP común y corriente.
Como podemos ver en la captura, estamos parados después de que se realizo el SELECT y la tabla interna LT_DATOS contiene datos.
En SAP hay dos tipos de clases, las que podemos desarrollar en un reporte Z, como vimos en el post anterior, o las clases globales que son las que definimos en la transacción SE24.
La principal diferencia entre una clase global y una local es que las locales son especificas a un reporte, mientras las clases globales pueden ser usadas desde cualquier lado.
Para definir una clase, vamos a la transacción SE24, para seguir con el ejemplo anterior vamos a volver a crear la clase vehículo.
Hacemos click en “Create”
En la siguiente ventana ingresamos una descripción y hacemos click en “SAVE”
Creamos el objeto como un objeto local.
Nos aparecerá la siguiente ventana donde debemos especificar el método a crear, visibilidad, tipo, etc.
El siguiente paso es definir los parámetros de los métodos, para eso seleccionamos un método y hacemos click en el botón “Parameters”.
Vamos a la solapa “Attributes” y definimos nuestra variable protegida.
Con nuestra clase con los métodos y variable definidas le damos click a activar.
Nos aparecerá una ventana como la siguiente en donde seleccionamos todos los objetos y le damos OK.
Nuestra clase debería haber quedado activa.
Finalmente hay que hacer el código que en cada método para que la clase haga algo.
Metodo obtener tipo:
WRITE 'AUTO'.
Método obtener marca:
WRITE 'FORD'.
Método set_notas:
lv_notas = notas.
Método ver_notas:
notas = lv_notas.
En este punto ya tenemos nuestra clase lista, solo nos resta volver a activarla para asegurarnos que esta todo OK.
Ahora nuestra clase estará disponible para ser usada desde cualquier reporte que se quiera crear.
Estaba refrescando un poco mi memoria de programación orientada a objetos (OOP) en ABAP, y decidí hacer el siguiente ejemplo, usando los conceptos de Encapsulamiento, Herencia y Polimorfismo.
Haciendo un ejemplo de polimorfismo podemos de paso abarcar también Herencia y Encapsulamiento, por ejemplo, digamos que queremos tener una clase con los atributos de vehículos, por ejemplo autos y motos. Para hacer esto podríamos definir una clase “Vehículos” que abarque a varios tipos de valga la redundancia vehículos.
Primero definimos una clase abstracta llamada vehículo, una clase abstracta tiene la particularidad que solo necesitamos definir, la DEFINITION y no tiene IMPLEMENTATION. Esto lo usaremos de mano de la definición de métodos para lograr polimorfismo.
CLASS lcl_vehiculo DEFINITION ABSTRACT.
PUBLIC SECTION.
METHODS: obtener_tipo ABSTRACT,
obtener_marca ABSTRACT,
set_notas ABSTRACT
IMPORTING notas TYPE string,
ver_notas ABSTRACT
EXPORTING notas TYPE string.
PROTECTED SECTION.
DATA: lv_notas TYPE string.
ENDCLASS.
En el código de arriba podemos ver que definimos la clase junto con sus métodos (Públicos) y en la sección Protegida la variable notas (Aca tenemos un ejemplo de encapsulamiento, donde la variable al estar dentro de la sección PROTECTED solo puede ser accedida desde si misma y clases heredadas. Podríamos pensar de una clase abstracta como un template o una “receta” para luego definir otras clases.
El paso siguiente seria por ejemplo definir una clase para los objetos de tipo auto usando la que ya tenemos.
CLASS lcl_auto DEFINITION
INHERITING FROM lcl_vehiculo.
PUBLIC SECTION.
METHODS: obtener_tipo REDEFINITION,
obtener_marca REDEFINITION,
set_notas REDEFINITION,
ver_notas REDEFINITION,
cantidad_puertas.
ENDCLASS.
En el código de arriba definimos la clase lcl_auto y podemos ver la sentencia INHERITING FROM esto indica que estamos HEREDANDO la clase lcl_vehiculo, con todos sus métodos y variables.
Tambien podemos ver que esta clase (lcl_auto) tiene un método mas (cantidad_puertas), cada clase sea heredada o no puede tener sus propios métodos.
En los métodos podemos ver que tienen la palabra clave REDEFINITION, esto quiere decir que el método lo vamos a redefinir para que haga lo que nosotros deseemos. Ahora creamos la implementacion de la clase.
En la implementacion de cada método podemos poner lo que nosotros queremos que el mismo haga. Podemos ver particularmente en el método set_notas que estamos seteando el valor de la variable lv_notas, esto es posible porque la misma esta declarada como PROTECTED, con lo cual una clase heredada puede modificar su valor. Si en lugar de PROTECTED fuese PRIVATE esto no seria posible.
Ahora hacemos lo mismo que antes pero para un objeto moto.
Primero declaramos la definición y luego la implementacion.
CLASS lcl_moto DEFINITION
INHERITING FROM lcl_vehiculo.
PUBLIC SECTION.
METHODS: obtener_tipo REDEFINITION,
obtener_marca REDEFINITION,
set_notas REDEFINITION,
ver_notas REDEFINITION.
ENDCLASS.
Como podemos ver en el ejemplo de arriba esta clase no tiene el método cantidad_puertas.
Finalmente solo resta hacer la declaración de los objetos y su llamado.
Para declarar los objetos hacemos lo siguiente:
"Declaramos los objetos.
DATA: lo_autos TYPE REF TO lcl_auto,
lo_motos TYPE REF TO lcl_moto.
"Creamos los objetos.
CREATE OBJECT lo_autos.
CREATE OBJECT lo_motos.
Primero creamos dos variables que van a contener los objetos y después creamos los mismos.
El ultimo paso es la llamada a los métodos de los objetos
*&---------------------------------------------------------------------*
*& Report ZPOLYTEST2
*&---------------------------------------------------------------------*
*&
*&---------------------------------------------------------------------*
REPORT ZPOLYTEST2.
"Ejemplo de encapsulamiento, herencia y polimorfismo en ABAP.
"Definimos una clase abstracta, podriamos llamarla una plantilla
"para las clases heredadas. Cuando definimos una clase como abstracta
"no tiene implementacion.
CLASS lcl_vehiculo DEFINITION ABSTRACT.
PUBLIC SECTION.
METHODS: obtener_tipo ABSTRACT,
obtener_marca ABSTRACT,
set_notas ABSTRACT
IMPORTING notas TYPE string,
ver_notas ABSTRACT
EXPORTING notas TYPE string.
PROTECTED SECTION.
DATA: lv_notas TYPE string.
ENDCLASS.
***********************************************************************
"Definimos una clase lcl_auto que hereda lcl_vehiculo y redefine los
"metodos de la clase padre (lcl_vehiculo).
CLASS lcl_auto DEFINITION
INHERITING FROM lcl_vehiculo.
PUBLIC SECTION.
"Los metodos con REDEFINITION son los originales de lcl_vehiculo.
"Como podemos ver podemos agregar nuestros propios metodos
"como por ejemplo cantidad_puertas que pertenece solo a esta clase.
METHODS: obtener_tipo REDEFINITION,
obtener_marca REDEFINITION,
set_notas REDEFINITION,
ver_notas REDEFINITION,
cantidad_puertas.
ENDCLASS.
"Implementamos la clase lcl_auto con sus metodos.
CLASS lcl_auto IMPLEMENTATION.
METHOD obtener_tipo.
WRITE 'AUTO'.
ENDMETHOD.
METHOD obtener_marca.
WRITE 'FORD'.
ENDMETHOD.
METHOD set_notas.
lv_notas = notas.
ENDMETHOD.
METHOD ver_notas.
WRITE lv_notas.
ENDMETHOD.
METHOD cantidad_puertas.
WRITE '4'.
ENDMETHOD.
ENDCLASS.
***********************************************************************
"Definimos una clase lcl_moto que hereda lcl_vehiculo y redefine los
"metodos de la clase padre (lcl_vehiculo).
CLASS lcl_moto DEFINITION
INHERITING FROM lcl_vehiculo.
PUBLIC SECTION.
METHODS: obtener_tipo REDEFINITION,
obtener_marca REDEFINITION,
set_notas REDEFINITION,
ver_notas REDEFINITION.
ENDCLASS.
"Implementamos la clase lcl_moto con sus metodos.
CLASS lcl_moto IMPLEMENTATION.
METHOD obtener_tipo.
WRITE 'MOTO'.
ENDMETHOD.
METHOD obtener_marca.
WRITE 'HONDA'.
ENDMETHOD.
METHOD set_notas.
lv_notas = notas.
ENDMETHOD.
METHOD ver_notas.
WRITE lv_notas.
ENDMETHOD.
ENDCLASS.
***********************************************************************
START-OF-SELECTION.
"Declaramos los objetos.
DATA: lo_autos TYPE REF TO lcl_auto,
lo_motos TYPE REF TO lcl_moto.
"Creamos los objetos.
CREATE OBJECT lo_autos.
CREATE OBJECT lo_motos.
"Llamamos a los metodos que setean las notas.
CALL METHOD lo_autos->set_notas( 'ALGO Autos' ).
CALL METHOD lo_motos->set_notas( 'ALGO 2 Motos').
"Llamamos a los metodos que muestran la informacion.
WRITE 'TIPO:'.
CALL METHOD lo_autos->obtener_tipo( ).
NEW-LINE.
WRITE 'MARCA:'.
CALL METHOD lo_autos->obtener_marca( ).
NEW-LINE.
WRITE 'NOTAS:'.
CALL METHOD lo_autos->ver_notas( ).
NEW-LINE.
WRITE 'PUERTAS:'.
CALL METHOD lo_autos->cantidad_puertas( ).
NEW-LINE.
WRITE '**************'.
NEW-LINE.
WRITE 'TIPO:'.
CALL METHOD lo_motos->obtener_tipo( ).
NEW-LINE.
WRITE 'MARCA:'.
CALL METHOD lo_motos->obtener_marca( ).
NEW-LINE.
WRITE 'NOTAS:'.
CALL METHOD lo_motos->ver_notas( ).
La clase cl_salv_table es una clase que contiene métodos relacionados a los ALV, con el método factory lo que hacemos es obtener una nueva instancia del ALV, pasando como parámetros lo_table, que es el que declaramos previamente, y los datos a mostrar (lt_sflight) que es donde guardamos el resultado del SELECT.
lo_columns = lo_table->get_columns( ). Con esta sentencia le indicamos que obtenga las columnas.
lo_columns->set_optimize( abap_true ). Con esta sentencia le indicamos que el ALV ajuste automáticamente el tamaño de las columnas.
lo_functions->set_all( ). Usamos este método para activar todas las funciones genéricas del ALV.
Con la sentencia lo_table->set_screen_status, lo que hacemos es especificarle un STATUS (que crearemos en breve).
Finalmente con el método lo_table->display( ). Mostramos el ALV.
Ahora agregamos el STATUS.
Para esto desde la se38 podemos hacer click en el siguiente icono para abrir el árbol de objetos:
En la ventana de objetos hacemos click derecho Create–>GUI STATUS:
Completamos la pantalla que nos aparece y le damos OK:
Nos aparecerá la siguiente pantalla:
Vamos al menu Extras–>Adjust Template:
Nos aparecerá otra ventana en donde seleccionamos “List Viewer” y le damos OK
Haciendo esto se nos completara todo lo que necesitamos, todos lo que nos resta es activar el GUI STATUS.
El código completo quedaría así:
REPORT zprueba_alv.
DATA: lo_table TYPE REF TO cl_salv_table,
lo_functions TYPE REF TO cl_salv_functions_list,
lo_columns TYPE REF TO cl_salv_columns_table.
SELECT * FROM sflight
INTO TABLE @DATA(lt_sflight)
UP TO 1000 ROWS.
IF sy-subrc = 0.
cl_salv_table=>factory( IMPORTING r_salv_table = lo_table
CHANGING t_table = lt_sflight ).
lo_columns = lo_table->get_columns( ).
lo_columns->set_optimize( abap_true ).
lo_functions = lo_table->get_functions( ).
lo_functions->set_all( ).
lo_table->set_screen_status(
pfstatus = 'ZSTATUS_GUI'
report = sy-repid
set_functions = lo_table->c_functions_all ).
lo_table->display( ).
ENDIF.
Finalmente si ejecutamos nuestro reporte vemos lo siguiente:
Si por ejemplo queremos bajar el listado a un archivo .XLSX, hacemos click en el siguiente botón y seleccionamos como aparece en la pantalla.
