SAP SERIES - Dashboards 4.x: Concept - Navigate the interface

Overview

Dashboards provides an interface that enables you to quickly and easily build and publish your dashboards.
In this tutorial, you will review the elements that make up the interface for Dashboards.

Watch this Tutorial

Dynamic Read Table With Key and Value

Introduction

The concepts of dynamic programming are part of the unique features that ABAP offers for business programming.

Exploiting the features of dynamic programming allows you to write powerful and flexible applications.

REPORT ZADN_SAMPLE.

*----------------------------------------------------------------------*
* -> CLASS lc_abnsample DEFINITION
*----------------------------------------------------------------------*
CLASS lc_abnsample DEFINITION.

  PUBLIC SECTION.

    TYPES : BEGIN OF ty_table_line,
              id    TYPE char02,
              name  TYPE char20,
              phone TYPE char15,
            END OF  ty_table_line.

    METHODS : constructor.

    METHODS : get_item_by_key IMPORTING p_key   TYPE char12
                                        p_value TYPE any
                              EXPORTING p_item  TYPE any.

  PRIVATE SECTION.

    TYPES : ty_table TYPE STANDARD TABLE OF ty_table_line.

    DATA : it_table TYPE ty_table,
           st_table TYPE LINE OF ty_table.

    METHODS : load_table_data.

ENDCLASS.                    "lc_abnsample DEFINITION

*----------------------------------------------------------------------*
* -> CLASS lc_abnsample DEFINITION
*----------------------------------------------------------------------*
CLASS lc_abnsample IMPLEMENTATION.

  METHOD constructor.

    me->load_table_data( ).

  ENDMETHOD.                    "constructor

  METHOD load_table_data.

    CLEAR : me->st_table.

    me->st_table-id    = 'AA'.
    me->st_table-name  = 'NAME AA'.
    me->st_table-phone = 'PHONE AA'.

    APPEND me->st_table TO me->it_table.

    CLEAR : me->st_table.

    me->st_table-id    = 'BB'.
    me->st_table-name  = 'NAME BB'.
    me->st_table-phone = 'PHONE BB'.

    APPEND me->st_table TO me->it_table.

    CLEAR : me->st_table.

    me->st_table-id    = 'CC'.
    me->st_table-name  = 'NAME CC'.
    me->st_table-phone = 'PHONE CC'.

    APPEND me->st_table TO me->it_table.

    CLEAR : me->st_table.

  ENDMETHOD.                    "load_table_data

  METHOD get_item_by_key.

    READ TABLE me->it_table WITH KEY (p_key) = p_value INTO me->st_table.

    p_item = me->st_table.

    CLEAR : me->st_table.

  ENDMETHOD.                    "get_item_by_key

ENDCLASS.                    "lc_abnsample DEFINITION

************************************************************************
************************************************************************
*                                                                      *
*                           PROGRAM FLOW LOGIC                         *
*                                                                      *
************************************************************************

PARAMETERS : pa_key   TYPE char12 DEFAULT 'ID', " Use : ID, NAME or PHONE
             pa_value TYPE char12 DEFAULT 'AA'. " For ID Use :
                                                " AA, BB or CC
                                                " For NAME Use :
                                                " NAME AA, NAME BB or NAME CC
                                                " For PHONE Use :
                                                " PHONE AA, PHONE BB or PHONE CC

START-OF-SELECTION.

  DATA : olc_abnsample TYPE REF TO lc_abnsample,
         o_data        TYPE REF TO data.

  FIELD-SYMBOLS :   TYPE ANY,
                   TYPE ANY.

  CREATE OBJECT olc_abnsample.

  CREATE DATA o_data TYPE lc_abnsample=>ty_table_line.

  IF olc_abnsample IS BOUND.

    ASSIGN o_data->* TO .

    olc_abnsample->get_item_by_key( EXPORTING p_key   = pa_key
                                              p_value = pa_value
                                    IMPORTING p_item  =  ).

    IF  IS ASSIGNED AND  IS NOT INITIAL.

      DO.

        ASSIGN COMPONENT sy-index OF STRUCTURE  TO .

        IF sy-subrc NE 0.

          EXIT.

        ELSE.

          WRITE / : .

        ENDIF.

      ENDDO.

    ELSE.

      WRITE / : 'Filter not found in table'.

    ENDIF.

    UNASSIGN : .

  ENDIF.

Dependency Injection in ABAP OO

Introduction

Dependency Injection (DI) is a technique and a set of design patterns that enable us to develop loosely coupled code. Instead of directly instantiating concrete classes whenever we need to invoke a particular service, we program against interfaces. Instances of these interfaces are injected into the code by the external client so that the code can vary independently of the Dependency.

Here we will take a detailed look at the DI pattern known as Constructor Injection. Since it is a design pattern, I have chosen to present it in the formal design pattern style.

How do we guarantee that a necessary Dependency is always available to the class we are currently developing?

By requiring all callers to supply the Dependency as a parameter to the class' constructor.

REPORT ZADN_SAMPLE.

*----------------------------------------------------------------------*
* -> INTERFACE IF_LOG_PERSISTENCE
*----------------------------------------------------------------------*
INTERFACE if_log_persistence.

  METHODS : save_log IMPORTING p_message TYPE char128.

ENDINTERFACE.                    "IF_LOG_PERSISTENCE

*----------------------------------------------------------------------*
* -> CLASS lc_log_in_email DEFINITION
*----------------------------------------------------------------------*
CLASS lc_log_in_email DEFINITION.

  PUBLIC SECTION.

    INTERFACES : if_log_persistence.

ENDCLASS.                    "lc_log_in_email DEFINITION

*----------------------------------------------------------------------*
* -> CLASS lc_log_in_email IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS lc_log_in_email IMPLEMENTATION.

  METHOD if_log_persistence~save_log.

    WRITE / : 'LOG SEND BY EMAIL',
              '-----------------',
              p_message.

  ENDMETHOD.                    "if_log_persistence~save_log

ENDCLASS.                    "lc_log_in_email IMPLEMENTATION

*----------------------------------------------------------------------*
* -> CLASS lc_log_in_file DEFINITION
*----------------------------------------------------------------------*
CLASS lc_log_in_file DEFINITION.

  PUBLIC SECTION.

    INTERFACES : if_log_persistence.

ENDCLASS.                    "lc_log_in_file DEFINITION

*----------------------------------------------------------------------*
* -> CLASS lc_log_in_file IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS lc_log_in_file IMPLEMENTATION.

  METHOD if_log_persistence~save_log.

    WRITE / : 'LOG SEND TO FILE',
              '-----------------',
              p_message.

  ENDMETHOD.                    "if_log_persistence~save_log

ENDCLASS.                    "lc_log_in_file IMPLEMENTATION

*----------------------------------------------------------------------*
* -> CLASS lc_log_in_database DEFINITION
*----------------------------------------------------------------------*
CLASS lc_log_in_database DEFINITION.

  PUBLIC SECTION.

    INTERFACES : if_log_persistence.

ENDCLASS.                    "lc_log_in_database DEFINITION

*----------------------------------------------------------------------*
* -> CLASS lc_log_in_database IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS lc_log_in_database IMPLEMENTATION.

  METHOD if_log_persistence~save_log.

    WRITE / :  'LOG CREATE IN DATABASE TABLE',
               '-----------------',
               p_message.

  ENDMETHOD.                    "if_log_persistence~save_log

ENDCLASS.                    "lc_log_in_database IMPLEMENTATION

*----------------------------------------------------------------------*
* -> CLASS LC_CALCULATOR DEFINITION
*----------------------------------------------------------------------*
CLASS lc_calculator DEFINITION.

  PUBLIC SECTION.

    METHODS : constructor IMPORTING p_log_target TYPE REF TO if_log_persistence,
              div         IMPORTING p_x TYPE i p_y TYPE i.

  PRIVATE SECTION.

    DATA : v_value TYPE i,
           v_msg   TYPE char128,
           o_log   TYPE REF TO if_log_persistence,
           o_exp   TYPE REF TO cx_sy_zerodivide.

ENDCLASS.                    "LC_CALCULATOR DEFINITION

*----------------------------------------------------------------------*
* -> CLASS LC_CALCULATOR IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS lc_calculator IMPLEMENTATION.

  METHOD constructor.

    me->o_log = p_log_target.

  ENDMETHOD.                    "CONSTRUCTOR

  METHOD div.

    TRY.

        me->v_value = ( p_x / p_y ).

        WRITE / : ' Division Operation = ', me->v_value.

      CATCH cx_sy_zerodivide INTO me->o_exp.

        me->v_msg = o_exp->get_text( ).

        o_log->save_log( me->v_msg ).

    ENDTRY.

  ENDMETHOD.                    "DIV

ENDCLASS.                    "LC_CALCULATOR IMPLEMENTATION

************************************************************************
************************************************************************
*                                                                      *
*                           PROGRAM FLOW LOGIC                         *
*                                                                      *
************************************************************************

*----------------------------------------------------------------------*
* -> DEFINE SCREEN ELEMENTS
*----------------------------------------------------------------------*
PARAMETERS : p_ltype TYPE i DEFAULT 1. " Use 1, 2, 3 or 4
                                       " with value of p_ltype

*----------------------------------------------------------------------*
* -> START-OF-SELECTION EVENT PROCESSING
*----------------------------------------------------------------------*
START-OF-SELECTION.

  DATA :   o_log_in_database TYPE REF TO lc_log_in_database,
           o_log_in_file     TYPE REF TO lc_log_in_file,
           o_log_in_email    TYPE REF TO lc_log_in_email,
           o_calculator      TYPE REF TO lc_calculator.

  CASE p_ltype.

    WHEN 1.

      CREATE OBJECT o_log_in_database.

      IF o_log_in_database IS BOUND.

        CREATE OBJECT o_calculator
          EXPORTING
            p_log_target = o_log_in_database.

        IF o_calculator IS BOUND.

          o_calculator->div( EXPORTING p_x = 1 p_y = 1 ). " Sucess
          o_calculator->div( EXPORTING p_x = 1 p_y = 0 ). " Error

        ENDIF.

      ENDIF.

    WHEN 2.

      CREATE OBJECT o_log_in_file.

      IF o_log_in_file IS BOUND.

        CREATE OBJECT o_calculator
          EXPORTING
            p_log_target = o_log_in_file.

        o_calculator->div( EXPORTING p_x = 2 p_y = 1 ). " Sucess
        o_calculator->div( EXPORTING p_x = 2 p_y = 0 ). " Error

      ENDIF.

    WHEN 3.

      CREATE OBJECT o_log_in_email.

      IF o_log_in_email IS BOUND.

        CREATE OBJECT o_calculator
          EXPORTING
            p_log_target = o_log_in_email.

        o_calculator->div( EXPORTING p_x = 3 p_y = 1 ). " Sucess
        o_calculator->div( EXPORTING p_x = 3 p_y = 0 ). " Error

      ENDIF.

    WHEN OTHERS.

      WRITE / 'NO IMPLEMENTATION ACTIVE FOR THIS LOG TYPE'.

  ENDCASE.

First Char to Upper: Regex Vs Function

REPORT ZADN_SAMPLE.

*----------------------------------------------------------------------*
* -> CLASS cl_regex_vs_Function DEFINITION
*----------------------------------------------------------------------*
CLASS cl_regex_vs_function DEFINITION.

  PUBLIC SECTION.

    METHODS : first_char_to_upper_regex    IMPORTING p_text TYPE char50,
              first_char_to_upper_function IMPORTING p_text TYPE char50.

  PRIVATE SECTION.

    DATA : v_input_text TYPE c LENGTH 50,
           v_match      TYPE match_result.

    DATA : it_matches TYPE match_result_tab.

ENDCLASS.                    "cl_regex_vs_Function DEFINITION


*----------------------------------------------------------------------*
* -> CLASS cl_regex_vs_Function IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS cl_regex_vs_function IMPLEMENTATION.

  METHOD first_char_to_upper_regex.

    me->v_input_text = p_text.

    WRITE / me->v_input_text.

    FIND ALL OCCURRENCES OF REGEX '\<[[:lower:]]' IN me->v_input_text RESULTS me->it_matches.

    LOOP AT me->it_matches INTO me->v_match.

      TRANSLATE me->v_input_text+me->v_match-offset(1) TO UPPER CASE.

    ENDLOOP.

    WRITE / me->v_input_text.

    CLEAR : me->v_input_text,
            me->v_match.

    REFRESH me->it_matches.

  ENDMETHOD.                    "first_char_to_upper_regex

  METHOD first_char_to_upper_function.

    me->v_input_text = p_text.

    WRITE / me->v_input_text.

    CALL FUNCTION 'ISP_CONVERT_FIRSTCHARS_TOUPPER'
      EXPORTING
        input_string  = me->v_input_text
        separators    = ' -.,;:'
      IMPORTING
        output_string = me->v_input_text.

    WRITE / me->v_input_text.

    CLEAR : me->v_input_text.

  ENDMETHOD.                    "first_char_to_upper_function

ENDCLASS.                    "cl_regex_vs_Function IMPLEMENTATION

************************************************************************
************************************************************************
*                                                                      *
*                           PROGRAM FLOW LOGIC                         *
*                                                                      *
************************************************************************

PARAMETERS : pa_text TYPE char50.

START-OF-SELECTION.

  DATA : o_cl_regex_vs_function TYPE REF TO cl_regex_vs_function.

  CREATE OBJECT o_cl_regex_vs_function.

  IF o_cl_regex_vs_function IS BOUND.

    o_cl_regex_vs_function->first_char_to_upper_regex( pa_text ).

    ULINE.

    o_cl_regex_vs_function->first_char_to_upper_function( pa_text ).

  ENDIF.

Using Regex to validate CNPJ number

This regular expressions matches CNPJ number. CNPJ is a Registration Number of Brazilian Companies.

REPORT ZADN_SAMPLE.

*----------------------------------------------------------------------*
* -> CLASS cl_regex_test DEFINITION
*----------------------------------------------------------------------*
CLASS cl_regex_test DEFINITION FINAL.

  PUBLIC SECTION.

    METHODS : check_cnpj IMPORTING p_cnpj TYPE string.

  PRIVATE SECTION.

    DATA: o_regex   TYPE REF TO cl_abap_regex,
          o_matcher TYPE REF TO cl_abap_matcher.

ENDCLASS.                    "cl_regex_test DEFINITION

*----------------------------------------------------------------------*
* -> CLASS cl_regex_test IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS cl_regex_test IMPLEMENTATION.

  METHOD check_cnpj.

* Create the regular expression:

    CREATE OBJECT o_regex
      EXPORTING
        pattern = '\d{2}.?\d{3}.?\d{3}/?\d{4}-?\d{2}'.

* Check to see if the CNPJ number matches the regular expression:

    CREATE OBJECT o_matcher
      EXPORTING
        regex = o_regex
        text  = p_cnpj.

    IF o_matcher->match( ) NE abap_true.

      MESSAGE 'Enter valid CNPJ number...' TYPE 'E'.

    ELSE.

      MESSAGE 'This is a valid CNPJ number...' TYPE 'S'.

    ENDIF.

  ENDMETHOD.                    "check_cnpj

ENDCLASS.                    "cl_regex_test IMPLEMENTATION

************************************************************************
************************************************************************
*                                                                      *
*                           PROGRAM FLOW LOGIC                         *
*                                                                      *
************************************************************************

START-OF-SELECTION.

  DATA : ocl_regex_test TYPE REF TO cl_regex_test.

  CREATE OBJECT ocl_regex_test.

  ocl_regex_test->check_cnpj( '12.043.129/0001-98' ). " IS VALID

  "ocl_regex_test->check_cnpj( '02.025.659/0001-981' ). " IS INVALID