Tener en cuenta que se debe configurar el servidor para que realice los envíos. Esta tarea debe realizarla un administrador del sistema.

Se debe ingresar el siguiente código fuente en la transacción SE38, como código ejecutable:

REPORT y_envio_mail.

* Declaracion de variables
DATA: go_mail_data TYPE REF TO cl_crm_email_data,
      gs_mail_recipient TYPE crms_email_recipient,
      gt_mail_recipients TYPE crmt_email_recipients,
      lw_body TYPE crms_email_mime_struc,
      gt_body TYPE crmt_email_mime_struc,
      gd_request_id TYPE sysuuid_x.
* Definicion de pantalla de selección
PARAMETERS: pa_namef TYPE text255 OBLIGATORY DEFAULT 'Prueba Mail',
            pa_from TYPE text255 OBLIGATORY DEFAULT 'prueba@mail.com',
            pa_namet TYPE text255 OBLIGATORY DEFAULT 'Prueba Mail',
            pa_to TYPE text255 OBLIGATORY DEFAULT 'prueba@mail.com',
            pa_subj TYPE text255 OBLIGATORY DEFAULT 'Mail de prueba'.

START-OF-SELECTION.
* Instanciar objeto datos de mail
  CREATE OBJECT go_mail_data.
* Remitente
  gs_mail_recipient-name = pa_namef.
  gs_mail_recipient-address = pa_from.
  APPEND gs_mail_recipient TO gt_mail_recipients.
  go_mail_data->from = gs_mail_recipient.
* Destinatarios
  gs_mail_recipient-name = pa_namet.
  gs_mail_recipient-address = pa_to.
  APPEND gs_mail_recipient TO gt_mail_recipients.
  go_mail_data->to = gt_mail_recipients.
* Asunto
  go_mail_data->subject = pa_subj.
* Cuerpo del mail
  lw_body-content_ascii = 'Cuerpo del mail de prueba. Nada en especial solo demostrar el éxito del envío'.
  APPEND lw_body TO gt_body.
  go_mail_data->body = gt_body.

END-OF-SELECTION.
* Enviar el e-mail
  CALL METHOD cl_crm_email_utility_base=>send_email
    EXPORTING
      iv_mail_data       = go_mail_data
    RECEIVING
      ev_send_request_id = gd_request_id.
  IF sy-subrc = 0.
    MESSAGE 'Mail enviado' TYPE 'S'.
  ENDIF.

Espero sus comentarios!

Hasta la próxima

El mundo de la consultoria es chico, eso lo decimos muy a menudo. Y por lo mismo, que mejor que tener un punto de reunión donde poder conversar y sobre todo, formar una comunidad basada en la confianza, entendimiento, profesionalismo y respeto.

Espero que se animen de todas las áreas de la consultoria SAP, a compartir sus inquietudes, y también sus experiencias. No solo a nivel técnico sino también funcionales (todos los módulos, administradores y usuarios!! Todos son bienvenidos.

fricadmin

Sin más preámbulos, comencemos.

Consideraciones previas

Debemos tener autorización para acceder a las transacciones SE37 y SE38.

Implementación

El nombre del patrón elegido es ZUSER_DATE_TIME, y mostrará justamente nombre de usuario, fecha y hora, como comentario dentro del programa. Los pasos para implementarlo son los siguientes:

Paso 1: Crear patrón. Estando posicionados dentro de un programa (SE38), vamos al menú Utilidades > Más Utilidades > Tratar patrón > Crear patrón.

Paso 2: Designar nombre al patrón.

Paso 3: Editar y guardar patrón. Al ingresar a la pantalla de edición de patrón, veremos que está vacía, debemos acceder al menú en la opción Modelo > Patrón dinámico. Aquí debemos reemplazar el código que aparece por defecto "*$&$EXIT" con "*$&$MUSTER" (sin las comillas). De esta manera, el sistema al momento de seleccionar el patrón, buscará su módulo de funciones asociado (que veremos a continuación).

Paso 4: Crear función asociada. Ahora que tenemos el patrón, debemos crear la función que generara el código dinámicamente. El nombre de la función debe ser <nombre_patrón> + "_editor_exit" (sin comillas). En nuestro ejemplo, la función a crear es ZUSER_DATE_TIME_EDITOR_EXIT. Con esto, todas las líneas que escribamos en la tabla de parámetro dentro de la función, aparecerá en el código fuente al invocar nuestro patrón.

Paso 5: Definir parámetro de salida de la función. La función debe contener un parámetro "Tabla", con nombre BUFFER, de tipo RSWSOURCET. Esta tabla es de tipo string, y todas las líneas que se agreguen en ella serán las que muestre el patrón en nuestro programa destino al invocarlo.

Paso 6: Codificación de la funcionalidad (la parte dinámica). Como ya les dije, se imprime el nombre de usuario, la fecha y la hora, con caracteres decorativos y como comentario. El código de ejemplo es el siguiente:

FUNCTION zuser_date_time_editor_exit.
*"----------------------------------------------------------------------
*"*"Interfase local
*"  TABLES
*"      BUFFER TYPE  RSWSOURCET
*"----------------------------------------------------------------------
  DATA: ld_date(10) TYPE c,
        ld_time(8) TYPE c.

  WRITE sy-datlo TO ld_date.
  WRITE sy-uzeit TO ld_time.

  REFRESH: buffer.
  CLEAR: buffer.
  buffer = '*----------------------'.
  APPEND buffer.

  CLEAR: buffer.
  CONCATENATE '* Usuario: ' sy-uname INTO buffer RESPECTING BLANKS.
  APPEND buffer.

  CLEAR: buffer.
  CONCATENATE '* Fecha  : ' ld_date INTO buffer RESPECTING BLANKS.
  APPEND buffer.

  CLEAR: buffer.
  CONCATENATE '* Hora   : ' ld_time INTO buffer RESPECTING BLANKS.
  APPEND buffer.

  CLEAR: buffer.
  buffer = '*----------------------'.
  APPEND buffer.
  CLEAR: buffer.

ENDFUNCTION.

Grabamos y activamos la función (método abreviado Ctrl+F3). Con esto queda terminado el patrón dinámico, para poder probarlo vamos a nuestro programa, y con el botón "Modelo" seleccionamos la opción "Otro" e ingresamos el nombre definido (ZUSER_DATE_TIME).

Finalmente, una consideración importante es que la función debería ser creada como objeto local (paquete $TMP), ya que por norma nunca desarrollamos en otros ambientes, con lo cual no necesitamos este patrón y menos su función asociada.

Espero les sea útil, ya que ayuda a agilizar el trabajo.

Hasta la próxima!

La función (SE37) se llama TAX_NUMBER_CHECK, y el código implementado es algo así:

START-OF-SELECTION.
* EJEMPLO FUNCION VALIDAR NIF.
  CALL FUNCTION 'TAX_NUMBER_CHECK'
    EXPORTING
      country             = 'CL'     " Pais (obligatorio)
*     NATURAL_PERSON_FLAG = 'X'      " Indicador persona natural
*     REGION              = ' '      " Region
*     STKZU               = ' '      " Sujeto a IVA
      tax_code_1          = '1-9'    " NIF 1
*     TAX_CODE_2          = ' '      " NIF 2
*     TYPE_OF_TAX_CODE_1  = ' '      " Tipo de NIF 1
*     TAX_CODE_3          = ' '      " NIF 3
*     TAX_CODE_4          = ' '      " NIF 4
    EXCEPTIONS
      not_valid           = 1
      different_fprcd     = 2
      OTHERS              = 3.
  IF sy-subrc <> 0.
* Control de errores
    CASE sy-subrc.
      WHEN 1.
        WRITE: 'Código NIF inválido'.
      WHEN 2.
        WRITE: 'Código NIF 1 no coincide con NIF 2'.
      WHEN 3.
        WRITE: 'Error en proceso'.
    ENDCASE.
  ELSE.
    WRITE: 'NIF correcto'.
  ENDIF.

Espero les sea útil.

Hasta la próxima

Los pasos mínimos para su funcionamiento son:

Implementación

Paso 1: Declaración de objetos.

* Variables Globales
* Formato de la tabla de salida
TYPES: BEGIN OF ty_salida,
        matnr LIKE mara-matnr,
        werks LIKE marc-werks,
        lgort LIKE mard-lgort,
        labst LIKE mard-labst,
        char1 TYPE char1,
       END OF ty_salida.
DATA: ti_salida TYPE STANDARD TABLE OF ty_salida,
      wa_salida TYPE ty_salida.
* Datos ALV
DATA: gr_table_alv   TYPE REF TO cl_salv_table,        " Objeto ALV
      gr_functions TYPE REF TO cl_salv_functions_list, " Funciones del ALV
      gr_content TYPE REF TO cl_salv_form_element.     " Cabecera

Paso 2: Recuperación de datos.

START-OF-SELECTION.
* Recuperacion de datos
  SELECT * FROM mara INTO CORRESPONDING FIELDS OF TABLE ti_salida.
  LOOP AT ti_salida INTO wa_salida.

    SELECT SINGLE werks
      FROM marc
      INTO wa_salida-werks
     WHERE matnr = wa_salida-matnr.

    SELECT SINGLE lgort labst
      FROM mard
      INTO CORRESPONDING FIELDS OF wa_salida
     WHERE matnr = wa_salida-matnr
       AND werks = wa_salida-werks.
    wa_salida-char1 = 'X'.

    MODIFY ti_salida FROM wa_salida.
  ENDLOOP.

Paso 3: Crear el objeto ALV y asignarle la tabla de datos.

END-OF-SELECTION.
  TRY.
* Crear el objeto ALV a partir de la tabla de salida
      cl_salv_table=>factory(
        IMPORTING
          r_salv_table = gr_table_alv
        CHANGING
          t_table      = ti_salida ).
    CATCH cx_salv_msg.                                  "#EC NO_HANDLER
  ENDTRY.

Paso 4 (opcional): Activar funciones estándar. Sin este paso, simplemente no se mostrará barra de herramientas (ordenar, totalizar, filtrar, etc.)

* Activar todas las funciones estandar del ALV
  gr_functions = gr_table_alv->get_functions( ).
  gr_functions->set_all( abap_true ).
* Defino cabecera
  PERFORM build_header CHANGING gr_content.
  gr_table_alv->set_top_of_list( gr_content ).
*
*
*&---------------------------------------------------------------------*
*&      Form  build_header
*&---------------------------------------------------------------------*
*      -->CR_CONTENT text
*----------------------------------------------------------------------*
FORM build_header CHANGING cr_content TYPE REF TO cl_salv_form_element.

  DATA: lr_grid   TYPE REF TO cl_salv_form_layout_grid,
        lr_grid_1 TYPE REF TO cl_salv_form_layout_grid,
        lr_label  TYPE REF TO cl_salv_form_label,
        lr_text   TYPE REF TO cl_salv_form_text,
        lr_layout  TYPE REF TO cl_salv_form_layout_logo,
        ld_text(255) TYPE c.
* crear objeto grilla para cabecera
  CREATE OBJECT lr_grid.
* Crear objeto layout para almacenar grilla e imagen
  CREATE OBJECT lr_layout.

* Titulo del reporte
  ld_text = 'Título Reporte ALV' .
  lr_grid->create_header_information(
  row = 1
  column = 25
  text    = ld_text
  tooltip = ld_text ).

  lr_grid->add_row( ).
  lr_grid_1 = lr_grid->create_grid(
                row    = 3
                column = 1 ).
* Cantidad de registros encontrados: etiqueta
  ld_text = 'Cantidad de Registros'.
  lr_label = lr_grid_1->create_label(
    row     = 1
    column  = 1
    text    = ld_text
    tooltip = ld_text ).
* Cantidad de registros encontrados: valor
  DESCRIBE TABLE ti_salida LINES ld_text.
  lr_text = lr_grid_1->create_text(
    row     = 1
    column  = 2
    text    = ld_text
    tooltip = ld_text ).

* Fecha de ejecucion: etiqueta
  lr_label->set_label_for( lr_text ).
  ld_text = 'Fecha'.
  lr_label = lr_grid_1->create_label(
    row    = 5
    column = 1
    text    = ld_text
    tooltip = ld_text ).
* Fecha de ejecucion: valor
  WRITE sy-datlo TO ld_text.
  lr_text = lr_grid_1->create_text(
    row    = 5
    column = 2
    text    = ld_text
    tooltip = ld_text ).
  lr_label->set_label_for( lr_text ).

* Transaccion OAER ->PICTURES -> OT -> Nombre de logo
* Asignar logotipo a la derecha
  lr_layout->set_right_logo( 'LOGO_BN').
* Agregar la información de cabecera a la izquierda
  lr_layout->set_left_content( lr_grid ).
*  cr_content = lr_layout.
  cr_content = lr_layout.

ENDFORM.                    " build_header

Paso 6: Mostrar ALV.

* Mostrar ALV
  gr_table_alv->display( ).

Consideraciones finales

Este método de creación de ALVs, si bien es muy flexible y permite una rápida implementación, también tiene algunas limitaciones a considerar, entre las que se encuentran:

• Máximo de 90 columnas.
• El ancho máximo de una columna es de 128 caracteres.
• Se permite 9 niveles de ordenamiento y totalización.
• El campo a totalizar debe ser grande como para también poder mostrar la suma o agregación.
• Solo permite mostrar tablas de tipo plano.
• No se permite campos de tipo “input” o modificables.

Pueden ver la documentación estándar asociada a la clase, en inglés, acá.

Espero sus comentarios.

Hasta la próxima!

Consideraciones previas

Debemos tener autorización para acceder a la transacción OAER. La imagen a utilizar debe estar creada.

Pasos de ejecución

Paso 1: Ingresar a transacción OAER. Ingresar como nombre de clase "PICTURES", tipo de clase "OT" y clave del objeto el nombre del logo que deseen crear, por ej.: "LOGO_ALV".  Una vez ingresados los datos ejecutar el programa.

Paso 2: Crear imagen. Para esto, en el panel inferior, en la pestaña "Crear", expandir las carpetas y dar doble-click en el tipo de documento "Imagen".

Paso 3: En la ventana popup que se desplegó, ingresar una descripción para la imagen, y seleccionar el archivo que se desea subir y aceptar. Listo!

Consideraciones finales

Ya tenemos creado el logo, ahora solo nos resta asociarlo a la ALV con el nombre definido en la pantalla de seleccion como clave del objeto (en mi caso "LOGO_ALV").

Saludos y éxitos!

La idea general es que mediante estos métodos, insertándolos en lugares clave de nuestros programas, por ejemplo antes y después de una recuperación de datos grande, podremos tener la sensibilidad para saber donde debemos ajustar e incluso liberar memoria en nuestros programas.

La clase

Para poder realizar estas mediciones, utilizaremos la clase CL_ABAP_MEMORY_UTILITIES (transacción SE24), la cual contiene los siguientes métodos:

• GET_MEMORY_SIZE_OF_OBJECT. A partir de un objeto enviado como parámetro, devuelve información detallada de sus características y uso de memoria.

Ejemplo de utilización

  DATA: gt_vbak TYPE STANDARD TABLE OF vbak WITH HEADER LINE,
        ld_alloc TYPE abap_msize,
        ld_used TYPE abap_msize.
  CALL METHOD cl_abap_memory_utilities=>get_memory_size_of_object
    EXPORTING
      object       = gt_vbak
    IMPORTING
      sizeof_alloc = ld_alloc
      sizeof_used  = ld_used.

• GET_TOTAL_USED_SIZE. Valor neto de la memoria utilizada por el programa en el punto en que se invocó el método.

Ejemplo de utilización

  DATA: size TYPE abap_msize.
  CALL METHOD cl_abap_memory_utilities=>get_total_used_size
    IMPORTING
      size = size.

• WRITE_MEMORY_CONSUMPTION_FILE. Método que no devuelve datos (sólo el código de retorno si es que pudo o no grabar), pero que genera un archivo detallado del uso de memoria. Para visualizar el archivo y realizar comparativas con archivos previos, se debe utilizar la transacción S_MEMORY_INSPECTOR.

Ejemplo de utilización

  DATA: ret_code TYPE i.
  CALL METHOD cl_abap_memory_utilities=>write_memory_consumption_file
    RECEIVING
      rc = ret_code.

• DO_GARBAGE_COLLECTION. Este método borra de memoria todos los objetos que ya no tienen referencia (y por tanto ya no se necesitan). Si bien la ejecución de este método ocurre en ciertos intervalos, puede ser necesario ejecutarla manualmente. Un ejemplo de objetos des-referenciados, es cuando se ejecuta una rutina que declara variables locales no estáticas; al finalizar esta rutina, las variables ya no están referenciadas y pueden ser borradas.

Ejemplo de utilización

  CALL METHOD cl_abap_memory_utilities=>do_garbage_collection.

Espero sus comentarios!

Instalación

Paso 1: Para proceder con el flujo lógico del desarrollo (diseño -> implementación), se deben crear los siguientes objetos de diccionario:

• Estructura de salida para el ALV. De esta forma, si queremos ajustar los textos o agregar campos, solo debemos modificar la estructura y recuperar los datos correspondientes.
• Tabla de saldos. Esta tabla es opcional si es que estas interesado en la funcionalidad del reporte ejemplo.

NOTA: para los elementos de datos Z que existan, solo fueron creados para cumplir con los nombres solicitados, pueden crearse uno similar o utilizar referencia estándar.

Paso 2: Crear el reporte. Según el estándar utilizado y los criterios de mejores prácticas, el programa está dividido en tres componentes:

• Reporte ejecutable. Es el programa principal, declara los eventos del reporte y permite una rápida visualización de su estructura y contenido.
• Programa “include”, declaraciones y pantallas. Contiene todos los objetos globales, así como también definiciones de pantalla.
• Programa “include”, pool de rutinas. Toda la funcionalidad está desarrollada en este include. Por norma personal y para mantener la performance del validador de sintaxis, si el mismo supera las 3.000 (tres mil) líneas de código, lo divido en mas includes (_F02, _F03, etc.).

Paso 3: Dentro del código fuente del reporte ejecutable se encuentra, como comentarios en la parte final, listados para definir los siguientes objetos de texto relacionados:

• Textos de selección
• Símbolos de texto
• Entradas en clase de mensaje. En este punto también aplica la NOTA del paso 1, pueden reutilizar una clase propia o crear una nueva. Lo importante es que el sentido de los mensajes no se pierda.

Consideraciones finales

Como pueden observar, esta forma de organizar y estructurar, nos permitirá de manera muy rápida generar nuevos reportes modificando solo algunos elementos, como son:

• Estructura de salida (la estructura como tal y las referencias en el programa para el nuevo nombre)
• Inicialización y Recuperación de datos

Espero sus comentarios, inquietudes, y sugerencias!

Hasta la próxima

Descargar –> aquí

Consideraciones previas

Debemos tener autorización para acceder al depurador y a las transacciones SE18, SE19 (opcional) y SE24.

El concepto a aplicar es que para ejecutar una BADI el sistema primero valida si esta se encuentra implementada y su implementación activa, y en caso afirmativo procede a su ejecución.

Tomaremos como ejemplo la transacción MIGO para entradas de mercancías.

Pasos de ejecución

Paso 1: Primero debemos insertar un break-point en la clase de consulta, que es la encargada de determinar si hay una implementación activa para la BADI. Ingresar a transacción SE24, la clase es CL_EXITHANDLER, el método que nos interesa es GET_INSTANCE. El break-point se puede colocar en cualquier lugar, aunque yo prefiero en la llamada al método GET_CLASS_NAME_BY_INTERFACE.

Paso 2: Con el break-point colocado, nos vamos a la transacción que deseamos analizar, en mi caso la MIGO, y ejecutamos la acción a evaluar (tengan en cuenta que dado el paso 1, el modo depuración se ejecutara con todas las acciones que se realicen en el sistema, con lo cual presionar F8 cuando se active en una acción no deseada). Al momento de activarse el depurador en la acción deseada (por ejemplo al grabar), veremos que en la llamada al método get_class_name_by_interface se encuentra un parámetro EXIT_NAME. Esta variable contendrá siempre el nombre de la BADI que se está evaluando, y por tanto si la implementamos, se activara en esta transacción y en esta acción.

Aquí se observa para el caso de la MIGO, una de las BADIs que se activa.

Paso 3: Finalmente, si encontramos la BADI que necesitábamos, solo resta ingresar a la transacción SE18 para crear una implementación o bien a la SE19 para ver/modificar una existente.

Consideraciones finales

Debido a que las BADIs existen en todos los programas estándar, hay que tener en cuenta que el break-point se activará en forma constante, con lo cual, es recomendable borrarlo una vez finalizado el análisis. Adicionalmente, tener en cuenta que puede ser que una misma BADI se ejecute en más de una transacción, por ejemplo al crear y también al modificar cierto documento, de manera que se puede querer agregar condiciones diferentes en cada caso.

LISTO! Con esto podremos analizar cualquier aplicación estándar y realizar búsqueda de BADIs!