SAP Community - ABAP Cloud

How to create a value help for custom and released domain fixed values?

2024-02-15T02:15:22.925000+01:00

Introduction

For creating value helps based on domain fixed values in ABAP Cloud the recommendation so far was to create custom CDS views based on the released CDS views DDCDS_CUSTOMER_DOMAIN_VALUE and DDCDS_CUSTOMER_DOMAIN_VALUE_T.

The drawback of this solution is

that you have to create dedicated CDS views for each domain and
that the aforementioned CDS views only work for domains that reside in software components owned by customers.

Based on a question in a forum of the German SAP user group DSAG where the question was raised whether there is no alternative solution I thought again about this requirement.

Instead of using CDS views it is possible just use one single custom entity which uses RTTI to retrieve the domain fixed values.

Result

When adding the new value help to the projection view as follows:

      @Consumption.valueHelpDefinition: 
      [{ entity: { name : 'ZI_DOMAIN_FIX_VAL' , element: 'low' } ,
         additionalBinding: [{ element: 'domain_name',
                               localConstant: 'BEL_API_RETCODE', usage: #FILTER }]
                               , distinctValues: true
                               }]
      Low,

We get the following result:

Implementation

The challenge to get this to work with just one custom entity is, to provide the name of the domain that is used as a value help via additional binding.

This can be achieved by using localConstant key word and in addition it needs the usage parameter set to #FILTER. This way we can specify the name of the domain whose domain fixed values shall be used within the coding.

Be careful !

It doesn't work if the element ("domain_name" in this case) is hidden in the Value Help CDS View (e.g. through "UI.hidden: true").

Custom Entity

The DDL source code of the custom entity looks like this:

@EndUserText.label: 'Get domain fix values'
@ObjectModel.resultSet.sizeCategory: #XS
@ObjectModel.query.implementedBy: 'ABAP:ZCL_GET_DOMAIN_FIX_VALUES'
define custom entity ZI_DOMAIN_FIX_VAL
{
      @EndUserText.label     : 'domain name'
      @UI.hidden : true 
  key domain_name : sxco_ad_object_name;
      @UI.hidden  : true
  key pos         : abap.numc( 4 );
      @EndUserText.label     : 'lower_limit'
      low         : abap.char( 10 );
      @EndUserText.label     : 'upper_limit'
      high        : abap.char(10);
      @EndUserText.label     : 'Description'
      description : abap.char(60);


}

Query implementation class

And the code of the query implementation class is as follows:

The domain name is retrieved from the filter that is filled via the additional binding.

Once the domain name has been retrieved the domain fixed values are being retrieved using RTTI as described in the following blog post Fetching texts for domain fixed values - SAP Community by Michał Badura.

Another option would be to use the XCO library.

CLASS zcl_get_domain_fix_values DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_rap_query_provider.
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS zcl_get_domain_fix_values IMPLEMENTATION.


  METHOD if_rap_query_provider~select.
    DATA business_data TYPE TABLE OF zi_domain_fix_val .
    DATA business_data_line TYPE zi_domain_fix_val .
    DATA(top)     = io_request->get_paging( )->get_page_size( ).
    DATA(skip)    = io_request->get_paging( )->get_offset( ).
    DATA(requested_fields)  = io_request->get_requested_elements( ).
    DATA(sort_order)    = io_request->get_sort_elements( ).

    DATA domain_name  TYPE sxco_ad_object_name  .
    DATA pos TYPE i.

    TRY.
        DATA(filter_condition_string) = io_request->get_filter( )->get_as_sql_string( ).
        DATA(filter_condition_ranges) = io_request->get_filter( )->get_as_ranges(  ).

        READ TABLE filter_condition_ranges WITH KEY name = 'DOMAIN_NAME'
               INTO DATA(filter_condition_domain_name).

        IF filter_condition_domain_name IS NOT INITIAL.
          domain_name = filter_condition_domain_name-range[ 1 ]-low.
        ELSE.
          "do some exception handling
          io_response->set_total_number_of_records( lines( business_data ) ).
          io_response->set_data( business_data ).
          EXIT.

        ENDIF.

        business_data_line-domain_name = domain_name .

        CAST cl_abap_elemdescr( cl_abap_typedescr=>describe_by_name( domain_name ) )->get_ddic_fixed_values(
          EXPORTING
            p_langu        = sy-langu
          RECEIVING
            p_fixed_values = DATA(fixed_values)
          EXCEPTIONS
            not_found      = 1
            no_ddic_type   = 2
            OTHERS         = 3 ).

        IF sy-subrc > 0.
          "do some exception handling
          io_response->set_total_number_of_records( lines( business_data ) ).
          io_response->set_data( business_data ).
          EXIT.
        ENDIF.

        LOOP AT fixed_values INTO DATA(fixed_value).
          pos += 1.
          business_data_line-pos = pos.
          business_data_line-low = fixed_value-low .
          business_data_line-high = fixed_value-high.
          business_data_line-description = fixed_value-ddtext.
          APPEND business_data_line TO business_data.
        ENDLOOP.

        IF top IS NOT INITIAL.
          DATA(max_index) = top + skip.
        ELSE.
          max_index = 0.
        ENDIF.

        SELECT * FROM business_data AS data_source_fields
           WHERE (filter_condition_string)
           INTO TABLE business_data
           UP TO max_index ROWS.

        IF skip IS NOT INITIAL.
          DELETE business_data TO skip.
        ENDIF.

        io_response->set_total_number_of_records( lines( business_data ) ).
        io_response->set_data( business_data ).

      CATCH cx_root INTO DATA(exception).
        DATA(exception_message) = cl_message_helper=>get_latest_t100_exception( exception )->if_message~get_longtext( ).

        DATA(exception_t100_key) = cl_message_helper=>get_latest_t100_exception( exception )->t100key.

        "do some exception handling

    ENDTRY.
  ENDMETHOD.
ENDCLASS.

Bring your own Git for SAP BTP ABAP Environment

2024-02-18T10:00:00.024000+01:00

Since its first announcement, SAP BTP, ABAP environment (a.k.a. Steampunk) has been using git-based repositories for customer lifecycle management under the hood. However, customer developers have hardly ever noticed this in daily work, and despite gCTS being used internally, it was hard to tap into the benefits of a git-based lifecycle. This now changes with the 2402 release of SAP BTP ABAP Environment.

You will be able to choose your own git service provider and thus also connect CI/CD pipelines (cf. CI/CD Tools for SAP BTP ABAP Environment) of your choice directly to the commit hooks of that service.

Prerequisites

First, you need to create a new git repository with an initial commit and branch at the git service of your choice. We have used GitHub in our example below. The repository must be accessible from the internet, i.e., not hidden behind a firewall. You need a user with permissions to clone, pull, and push the chosen repository. Lastly, the SAP BTP ABAP systems you want to connect (e.g., dev, test, prod) all need to belong to the same global account.

Create and clone a new Software Component

You log on to the SAP Fiori Launchpad of your development system with a user holding a business role from template id SAP_BR_ADMINISTRATOR and go to the Manage Software Components app to create a new software component. With release 2402 you will notice the additional, optional Repository URL field on the New Software Component dialog:

As the name suggests, here you enter the URL of your initially empty git repository that your software component shall be connected to. The repo must already have an initial branch, usually „main“. Otherwise the user cannot clone the repository. In this case the user will see a „No branches were found. Please create a branch before cloning.“ message in the clone popup.

You will see the resulting software component as available in the Manage Software Components app. The connection to your git repository is registered but not yet locally cloned.

Next step is to clone the remote git repository to your app server’s local filesystem from where the objects will be imported into the ABAP runtime. You need to provide user credentials with sufficient privileges for this purpose on the first page of the Clone Software Component dialog. After the credentials have been validated, you must select a branch to be checked out and decide on the local role of your repository. For development systems, choose the role “Source” so that you can also push from your system to the remote repository.

Once you are done, you will see a new commit on your remote repository that has written a new file “.gcts.properties.json”. This file must not be deleted because it stores essential configuration data for gCTS.

Branching

Afterwards you need to pull the branch of your choice using the Manage Software Components app. It is important that your branches always contain the aforementioned “.gcts.properties.json” file created by the commit titled “Modify repository layout”. Otherwise, you will not be able to pull this branch to your system. Then you are ready to start some development.

Develop and release transports

As a developer you can now create some objects in ABAP Development Tools for Eclipse (ADT) underneath the structure package corresponding to the name of your software component. Changes will be recorded in tasks of transport requests as usual. Release them when you are ready with your development.

As soon as you have released a transport request, a new commit will become visible in your remote git repository on the active branch that you have chosen. You will notice that new files and folders have been created there.

Pull into target system

To import your released transport into a target system (e.g., your test or production system), your administrator must clone the same software component to the desired system. The only difference is the “Repository Role”, which now must be set to “Target”. After pulling the corresponding commit to the system, the changes will be imported to the ABAP runtime.

Fingerprints and external changes

Now let’s have a closer look at the details of the files written to git.

Besides the metadata and sources, a file FINGERPRINT.json is written for every transported object. It contains fingerprints for every include file of the object, which will be validated in the target system during pull from git.

This fingerprint is calculated from the content hash of your file and a secret that is only known internally to ABAP Cloud systems of your global account. The following picture gives an overview.

This ensures that only commits pushed (and validated) from ABAP Cloud systems can be pulled to target systems. Otherwise, stability of target systems could be jeopardized when external changes from git that have not passed ABAP Cloud allow-list checks and consistency rules are inadvertently imported. This is especially important for production systems.

Now let’s check what happens when you try pull an external commit. Therefore, let’s arbitrarily change some file directly in your git service.

When trying to pull this into one of the ABAP Cloud systems in your account via the Manage Software Components app, you will receive an error in the Execution Log.

You can further drill down into the transport logs to finally see that there was an exception when matching the fingerprints of pulled files.

To recover from this situation, you must revert the conflicting commit on your remote repository. It is important that the fingerprints match again to the files as originally exported from your development system, before pulling again to an ABAP Cloud system.

Outlook

Being able to edit ABAP sources with external tools would have a lot of benefits, e.g., for conflict resolution after merging or cherry-picking. For the future, the idea is to allow also external changes by falling back to an inactive import in case of mismatching fingerprints. This will ensure that all necessary ABAP Cloud checks are conducted when activating the objects again in the importing (development) system.

Another restriction is that there is currently no straightforward possibility to migrate existing applications to your own git repository, especially when it has already been deployed to production. This feature is of course also high on the wish list.

Further Information

SAP Help on How to Configure Your Git Repository
Tutorial on Transport a Software Component Between two Systems Using Any Git Repository (BYOG)

SAP BTP ABAP Environment – Release 2402

2024-02-22T23:14:19.045000+01:00

As follow-up to our previous release 2311, this blog post provides an update concerning our most recent release 2402, which is available for customers and partners since last weekend. This particular release features highlights such as a Bring-your-own-Git capability, support for Enterprise Search and Data Replication from ABAP.

All available new features can be found on the official release notes page.

Bring-your-own git

You can now connect own Git repositories to your ABAP environment system via the Manage Software Components app. This allows you to manage the lifecycle of software components in a customer-chosen Git service as well as to connect custom CI/CD services. Please note that changes to the code in Git are only allowed through transport requests in the system (details).

Enterprise Search

With enterprise search, it is possible to create a CDS-based search model via enterprise search annotations. These annotations refer to a suitable CDS view entity which can be either reused or created from scratch (details).

Data Replication with ABAP as a Source

The ABAP environment can now be used as source for data replication to SAP Datasphere. The replication scenario covers both initial load and delta extraction as well as replication from public and custom CDS view entities (details).

SOAP Provider Model

The SOAP Provider Model now allows you to expose SOAP services for inbound communication. The description of the service is done via a WSDL file (details).

ABAP Development Tools

Support for SAP-provided CDS aspects to store field definitions and calculations, such as CDS expressions
Support for displaying system client in editor tab (details)
Enhancements to the refactoring functionality for ABAP classes and interfaces (details)
Availability of the server-driven UI editor for ILM objects (ILMB) (details)

ABAP RESTful Application Programming Model

Support for the definition of static and instance feature control for fields which have been added for key user extensibility
Support for generating custom OData UI services based on RAP BO interfaces using a generator wizard

Administration & Operations

Support for displaying and analyzing ABAP runtime errors with the new ABAP Runtime Errors app (details)
Support for displaying dependency of scope items in business role templates (details)
Support for displaying components to which a restriction type belongs to create incidents (details)
Support for using additional metrics for e-mail transmissions and changes to database table entries in the Health Monitoring app (details)
Support for using additional metric for e-mail transmissions in SAP Cloud ALM (details)
Support for copying restrictions from a deprecated restriction type using Mass Change Wizard (details, details)
Support for monitoring system workload with focus on metrics such as ABAP and HANA CPU time as well as processing time (details)
Enhancements to the monitoring screens for sampled work process data (details)
Support for merging of spaces or pages in the SAP Fiori Launchpad via respective apps

Continuous Integration and Delivery

Support for MANAGE_SOFTWARE_COMPONENTS API to work with software components on ABAP Environment systems

Infrastructure

Support for elastic scaling of application servers (blog post and details)

Integration & Connectivity

Support for adding the AIR key to a SOAP request in the HTTP header (details)
Support for configuring event filters for outbound event topics via Enterprise Event Enablement - Maintain Event Channel Binding app (details)
Support for integrating enterprise event enablement with Advanced Event Mesh service plan (details)
Support for the specification of customized OAuth scopes in communication arrangements
Availability of the new function module RS_ABAP_GET_NAMETAB_INFOS_E in ATC scenarios, which comes with new versions of the source code extractor notes bundled in the SAP Note (details)
Support for Refresh Allowed checkbox and Refresh Token Expiry Time in communication systems (details)
Support for displaying dependency of scope items in communication scenarios (details)

Additional Information

You can find the product page on SAP BTP, ABAP Environment | SAP Help Portal

For technical documentation, please refer to our Standalone Documentation.

Please refer to SAP BTP, ABAP environment Roadmap for more details about planned features as part of the product roadmap.

As always, please let us know if you have questions.

Stay healthy and take care!

Customer & Partner Roundtable for SAP BTP ABAP Environment #10

2024-02-27T18:59:52.646000+01:00

💡 Update

Thanks for joining our last roundtable. If you weren’t able to join, you can find the slides and the recording from March 19th and all the previous sessions in this GitHub repository.

References shared in the roundtable:

👉 The call for contributions for one of the upcoming roundtables is open!

If you want to show a demo or share a use case scenario for SAP BTP ABAP Environment send us an email and we will get back to you.

Introduction

As SAP BTP ABAP environment (aka Steampunk) and ABAP Cloud became more and more popular inside and outside of SAP, there is a high demand for rolling out the latest product news and updates, asking questions, and of course showing demos.

💡 If you weren’t able to join one of our previous roundtables, you can find the slides presented, recordings, and further references in this GitHub repository.

Meeting Information

When:

March 19th, 4:00 - 5:00 PM CET – Zoom Meeting (please register in advance)

Who:

All interested customers, partners, and stakeholders are invited to join and exchange ideas and feedback with others and the product team
Steampunk team: Frank Jentsch (Product Lead for SAP BTP ABAP Environment), Guido Derwand & Arne Harren as the project leads for BTP ABAP infrastructure topics, Iwona Hahn & Burcu Karlidag

Preliminary Agenda:

Product news
Important Update: Changes to Free Tier Option for SAP BTP ABAP Environment
New features: Elastic Scaling of Applications Servers & Steampunk on Google Cloud (GCP) (including demo)
Q&A

Looking forward meeting you!

Check out our SAP Business Technology ABAP Environment page in SAP Community for product updates and upcoming events.

Classic APIs for Tier 2 ABAP Cloud Development in SAP S/4HANA Cloud Private Edition

2024-02-28T08:38:22.351000+01:00

The following blog post relates to implementation of clean core extensions on top of SAP S/4HANA Cloud Private Edition. We introduce a set of classic APIs that can be leveraged in the Cloud API enablement layer to build custom applications and extensions while keeping the core clean.

In 2022 SAP announced the availability of the new  ABAP Cloud development model in SAP S/4HANA Cloud Private Edition and SAP S/4HANA. More information about that can be found in the blog post
How to use Embedded Steampunk in SAP S/4HANA Cloud, private edition and in on-premise. The part of the announcement is the new  ABAP extensibility guide. In this guide, the 3-tier model was introduced to set up ABAP Cloud in SAP S/4HANA Cloud Private Edition and SAP S/4HANA as the default extensibility model while keeping full flexibility in these environments. The 3-tier model offers customers and partners the environment to build clean core extensions.  

In this blog, we will focus on Classic APIs for tier 2 developments – where to find and how to use them to develop clean core extensions.

What is a Classic API and Cloud API enablement and when should you use it?

SAP recommends that new custom developments/extensions are done by default in tier 1 layer. It follows a pure ABAP Cloud extensibility model that allows the usage of released public SAP APIs only (ABAP Cloud APIs). Custom objects are created in language version ABAP for Cloud Development. ABAP Cloud rules are enforced by syntax and runtime checks.

The question is - what happens when such a public SAP API is missing?

The answer is customer implementation with tier 2 – Cloud API enablement.

You can mitigate the missing ABAP Cloud APIs via tier 2 Cloud API enablement by building custom wrappers around the listed Classic APIs using classic ABAP as language version. Then release the wrapper for ABAP Cloud development to be used for your own tier 1 developments. ABAP Test Cockpit (ATC) should be used to establish governance for tier 2 development by enforcing the syntax of ABAP Cloud and controlling usage of non-released APIs via ATC exemptions.

Refer to blog for details -
ABAP Cloud – How to mitigate missing released SAP APIs in SAP S/4HANA Cloud, private edition and SAP S/4HANA – The new ABAP Cloud API enablement guide | SAP Blogs

Where is the list of the available Classic APIs in SAP S/4HANA Cloud Private Edition?

The list of available S/4HANA Cloud Private Edition Classic APIs can be downloaded from GitHub - SAP/abap-atc-cr-cv-s4hc

Classic APIs for tier 2 consumption are offered across different application areas in SAP S/4HANA, such as Financial Accounting, Master Data Governance, Policy Management (FS-PM), SCM Basis, Advanced Planning and Optimization (APO), HCM – Payroll and Personnel Management, Bill of Materials, Plant Maintenance, Industry Solutions such as IS-Utilities.

The list of objects is release independent. Reason is that the classic APIs are well-known from old OP releases and are all already delivered in 2022)

The JSON file “objectClassifications.json” has only the recommended Classic APIs and the substituted objects. The state values are:

classicAPI: Objects nominated by SAP as classic API to be consumed in a self-released custom wrapper.
noClassicAPI: Link to another Classic API with improved scope

The JSON file is designed to be reused in other applications like ATC (ABAP Test Cockpit) and stands for the positive amount of Classic APIs.
To use the content in ATC, please implement note 3449860 - ATC Checks 'Usage of Released APIs' and 'Usage of Released APIs (Cloudification Repository)' Support of Classic APIs

The csv file “objectClassifications.csv” contains additional content for offline purposes. It might be helpful in cases of implementation project discussions to evaluate extensibility options in specific business areas or if the can be used in ABAP Cloud context.

The list has the following classifications:

TI2: Objects nominated by SAP as classic API to be consumed in an own custom wrapper.
SUB: no classic API but link to another Classic API with improved scope.
NA: Not intended to be a classic API either due to modern successor (public SAP API) or technical limitations.

How to use the file

For now, you can download the content and import the file into excel to display the table content.

In general, you can filter the Classic API list by application components to focus on your desired business application areas. The main use case is to find the objects with the classification TI2. These objects can be wrapped for example in a custom class method in classic ABAP and released for ABAP Cloud development.

Objects with the classification SUB have a link to the improved classic API successor object. The ABAP development tools for Eclipse offers on top the possibility to display modern replacements for legacy APIs. For objects with the classification NA – not applicable – there are several reasons why it is not possible to consume them in Cloud API enablement, including:

The object is not compatible with the ABAP RAP (RESTful Application Programming) development model, because there is an explicit commit work or violating the guidelines.
The object only covers a specific, SAP internal use case.
The object is not compatible with newer SAP S/4HANA functions and features.

In the future more tools for consuming this Classic API information are planned to improve the developer experience in the development process.

Access to Released and Classic API Viewer:

If you want to browse through all existing APIs:

released APIs for ABAP Cloud to be consumed in tier1 layer: Cloudification Repository Viewer (sap.github.io)

classic APIs to be consumed in tier2 API enablement: Cloudification Repository Viewer (sap.github.io)

How to create custom wrappers using Classic APIs

Details how to consume the Classic APIs can found at:

Cloud API Enablement blog and guidelines blog

and Cloud API Enablement Guidelines PDF

Refer to this blog for details on ATC setup How the ABAP Test Cockpit supports you to adopt ABAP Cloud

Example: tutorial on how wrap a non-released object and release it for tier 1 consumption Implement a Wrapper for the "Create Purchase Requisition" (BAPI_PR_CREATE) function module | SAP Tutorials

If more APIs are needed, please send your requests via SAP Customer Influence Channel - SAP S/4HANA Cloud Private Edition for Extensibility and Integration (APIs)

How to reuse access control from a released SAP CDS entity in ABAP Cloud?

2024-02-28T15:14:56.649000+01:00

Introduction

When you want to reuse the access control settings from a released SAP CDS entity such as I_BUSINESSUSERBASIC in ABAP Cloud (e.g in SAP BTP ABAP Environment or in a software component in an SAP S/4HANA on prem or private cloud system that uses software components with ABAP Cloud) you might try the following DCL source code:

@EndUserText.label: 'Test DCL inheritence'
@MappingRole: true
define role ZI_BUSINESSUSERBASIC_NOTWORK {
grant
select
on
ZI_BUSINESSUSERBASIC
where
INHERITING CONDITIONS FROM ENTITY I_BUSINESSUSERBASIC;
}

This however would cause the following error message:

The use of inheritance is restricted in this language version

The reason is that the reuse of access control requires a special syntax.

Solution

In order to reuse the access controll settings of a base entity that has been released by SAP you have to equip your custom code entity with a [1..1] association _toBaseEntity that points back to the base entity.

@AccessControl.authorizationCheck: #MANDATORY
@EndUserText.label: 'test dcl inheritence'
define view entity ZI_BusinessUserBasic
as select from I_BusinessUserBasic

association [1..1] to I_BusinessUserBasic as _toBaseEntity on $projection.BusinessPartner = _toBaseEntity.BusinessPartner

{
key BusinessPartner,
BusinessPartnerUUID,
LastName,
FirstName,
PersonFullName,
FormOfAddress,
AcademicTitle,
AcademicSecondTitle,
CorrespondenceLanguage,
MiddleName,
AdditionalLastName,
BirthName,
NickName,
Initials,
LastNamePrefix,
LastNameSecondPrefix,
NameSupplement,
UserID,
IsMarkedForArchiving,
BusinessPartnerIsBlocked,
CreatedByUser,
CreationDate,
CreationTime,
LastChangedByUser,
LastChangeDate,
LastChangeTime,
IsBusinessPurposeCompleted,
AuthorizationGroup,
DataControllerSet,
DataController1,
DataController2,
DataController3,
DataController4,
DataController5,
DataController6,
DataController7,
DataController8,
DataController9,
DataController10,
/* Associations */
_BusinessPartnerExternalID,
_BusinessPartnerRole,
_User,
_WorkplaceAddress,
_toBaseEntity
}

In addition you have to use the following syntax in your DCL.

The statement

REPLACING { ROOT WITH _toBaseEntity }

makes sure that inheritence will still work even if SAP would add additional authorization checks in the where clause of the DCL that protects the released base entity I_BusinessUserBasic.

Though the syntax seems to be not self explaining at a first glance it is straight forward to simply create the above mentioned [1..1] association to the based entity.

@EndUserText.label: 'Test DCL inheritence'
@MappingRole: true
define role ZACL_ZI_BUSINESSUSERBASIC {
    grant
        select
            on
                ZI_BUSINESSUSERBASIC
                    where             
                        INHERITING CONDITIONS FROM ENTITY I_BUSINESSUSERBASIC
                         REPLACING { ROOT WITH _toBaseEntity }                         
                         // AND ...    to make it more restricive                         
                         // OR ....   to widen access for additional autorizations 
                         ;
                        
}

Hope this helps when you run into this issue.

CDS View: Time comparison

2024-02-28T22:27:29.400000+01:00

This blog is about CDS scalar functions - CALENDER_SHIFT and CALENDER_OPERATIONS and how to use it in analytical queries for time comparison. Similarly FISCAL_CALENDAR_SHIFT and FISCAL_CALENDAR_OPERATION can be used.

These CDS scalar functions are used to compare the measure value of current time period with previous time period. Further it can be used to calculate measure value for year to date (YTD), month to date (MTD) or quarter to date (QTD). Current member can only be used when time dimensions are in drilldown else restricted measure is used. The usage of current member is not as fast as restricted measure. Detail specification of the mentioned scalar functions can be found in Help.

Usage of Current Member

This function can be used by modeling an association with the cube. In the ON-condition, the scalar functions are specified on the right side.

association to ZOQ_FLIGHT as _previousMonth
    on _previousMonth.fyearMonth = calendar_shift( base        => $projection.fyearMonth, 
                                                   base_level  => calendar_date_level.#MONTH,	
                                                   shift       => abap.int2'-1',
                                                   shift_level => calendar_date_level.#MONTH  )

Constraints:

Current member to work properly, we have to mark all the time fields which are related with annotation - @ObjectModel.value.derivedFrom. We should also specify semantics. for example,

key fldate,
@ObjectModel.value.derivedFrom: 'fldate'
@Semantics.calendar.yearMonth: true
@ EndUserText.label: 'FL Month'
_calday.calmonth as fyearMonth,

The base parameter must be filled with the same field name as it appears on the left: for example, the field name __previousMonth.fyearMonth should be same as base => $projection.fyearMonth

The Semantics of field $projection.fyearMonth must match the base_level parameter. As In the cube view example, the fyearMonth field has the annotation @Semantics.calendar.yearMonth: true, base_level is specified as calendar_date_level.#MONTH.
In the example to restrict the measure to the previous month, shift is set to -1 and shift_level is set to #MONTH. There is a constraint in using shift_level with base_level : for example for base level #MONTH, shift _level can be #MONTH,#QUARTER or #YEAR But can’t be #DAY.

Example 1: Time comparison with time in drill-down (Current Member Variables)

@AccessControl.authorizationCheck: #NOT_ALLOWED
@EndUserText.label: 'Query: Current Memeber on Month'
define transient view entity ZLR_PC_CM_1 
provider contract analytical_query
as projection on ZOQ_FLIGHT

  association to ZOQ_FLIGHT as _previousMonth
    on _previousMonth.fyearMonth = calendar_shift( base        => $projection.fyearMonth, 
                                                   base_level  => calendar_date_level.#month,
                                                   shift       => abap.int2'-1',
                                                   shift_level => calendar_date_level.#month  )
  association to ZOQ_FLIGHT as _firstMonthOfQuarter
    on _firstMonthOfQuarter.fyearMonth between calendar_operation( base           => $projection.fyearMonth,
                                                                  base_level      => calendar_date_level.#month,
                                                                  operation       => calendar_date_operation.#first,
                                                                  operation_level => calendar_date_level.#quarter )  
                                          and $projection.fyearMonth  
      
  association to ZOQ_FLIGHT as _CMM1_CMP1
    on _CMM1_CMP1.fyearMonth between calendar_shift( base        => $projection.fyearMonth, 
                                                     base_level  => calendar_date_level.#month,
                                                     shift       => abap.int2'-1',
                                                     shift_level => calendar_date_level.#month  )     
                                 and calendar_shift( base        => $projection.fyearMonth, 
                                                     base_level  => calendar_date_level.#month,
                                                     shift       => abap.int2'1',
                                                     shift_level => calendar_date_level.#month  )  
 {
  @AnalyticsDetails.query: {
    axis: #ROWS,
    totals: #SHOW
  } 
  @EndUserText.label: 'Year Quarter'
  flquarter,
  
   @AnalyticsDetails.query: {
     axis: #ROWS,
     totals: #SHOW
  }  
   @EndUserText.label: 'Year Month'
   fyearMonth,
  
   @AnalyticsDetails.query.axis: #FREE
   .hidden: true
   currency,
   
   @Semantics.amount.currencyCode: 'currency'
   paymentsum,
   
   _previousMonth.currency as PrevMonthCurrency,
   @Semantics.amount.currencyCode : 'PrevMonthCurrency'
   @EndUserText.label: 'Previous Month'
   _previousMonth.paymentsum as PrevMonthPayment,

   _firstMonthOfQuarter.currency as firstMonthOfQuartCurrency,
   @Semantics.amount.currencyCode : 'firstMonthOfQuartCurrency'
   @EndUserText.label: 'Quarter to today'
   _firstMonthOfQuarter.paymentsum as firstMonthOfQuartPayment, 

   _CMM1_CMP1.currency as last3MonthCurrency,
   @Semantics.amount.currencyCode : 'last3MonthCurrency'
   @EndUserText.label: 'Previous month To next month'
   _CMM1_CMP1.paymentsum as CMM1_CMP1Payment

}
where flyear =  '2019'
  and currency = 'EUR'

Result:

In this Result

Red- column Previous Month -shows value from previous month.
Yellow- column Quarter to Today- shows the aggregate values of previous months in this quarter.
Green- column Gliding window of 3 month- shows aggregate value of previous month + current month + next month.

Usage of Restricted Measure

This can be done using the CASE statement, where one of the scalar function is used.

   case when fyearMonth = calendar_shift( base        => $parameters.p_month, 
                                          base_level  => calendar_date_level.#MONTH,
                                          shift       => abap.int2'-1',
                                          shift_level => calendar_date_level.#MONTH ) then paymentsum end as paymentPrev

Constraints:

The base parameter must be a parameter or a literal.
The type of parameter or literal must match to base_level. In the example for base_level calendar_date_level.#MONTH, the type of parameter p_month must be NUMC6.
In the example to restrict the measure to the previous month, shift is set to -1 and shift_level is set to #MONTH.

Example 2: Time comparison (Restricted key figure)

@AccessControl.authorizationCheck: #NOT_ALLOWED
@EndUserText.label: 'Query: Current Memeber on Month'
define transient view entity ZLR_PC_RSRT_SHIFT1 
provider contract analytical_query
with parameters
       p_month : /bi0/oicalmonth
as projection on ZOQ_FLIGHT
 {
   @AnalyticsDetails.query: {
    axis: #ROWS,
    totals: #SHOW
  } 
   carrid,
   
   currency,
   
   virtual currCur : abap.cuky,
   @Semantics.amount.currencyCode : 'currCur'
   @Consumption.dynamicLabel: {
     label: 'Bookings &1',
     binding: [{ index : 1 , element : 'fyearMonth' }]
   } 
      
   case when fyearMonth = $parameters.p_month then paymentsum end as paymentCur,
   
   virtual currPrev : abap.cuky,
   @Semantics.amount.currencyCode : 'currPrev'
   @Consumption.dynamicLabel: {
     label: 'Previous Bookings &1',
     binding: [{ index : 1 , element : 'fyearMonth' }]
   } 
     
   case when fyearMonth = calendar_shift( base        => $parameters.p_month, 
                                          base_level  => calendar_date_level.#month,
                                          shift       => abap.int2'-1',
                                          shift_level => calendar_date_level.#month  ) then paymentsum end as paymentPrev,  
   
  
   
   virtual currLastInYear : abap.cuky,                                     
   @Semantics.amount.currencyCode : 'currLastInYear'
   @Consumption.dynamicLabel: {
     label: 'Bookings from &1 To &2',
     binding: [{ index : 1 , element : 'fyearMonth', replaceWith: #LOW },
               { index : 2 , element : 'fyearMonth', replaceWith: #HIGH }]
   }  
   case when fyearMonth between calendar_operation( base            => $parameters.p_month, 
                                              base_level      => calendar_date_level.#month,
                                              operation       => calendar_date_operation.#first,
                                              operation_level => calendar_date_level.#year  ) and $parameters.p_month then paymentsum end as paymentToDate                                            
 
}
where currency = 'EUR'

Result:

In this example I have used @Consumption.dynamicLabel to dynamically set the column label with values calculated from parameter.

Release Info:

On-Prem SAP_BW from 7.58 and Cloud from 2308

Related Notes:

3270090-CurrentMember + FemsN

3359468-Current Member on reference characteristic and selection for Partial Time Characteristic

How to find SAP APIs for SAP S/4HANA 3-tier extensibility model

2024-02-29T20:45:17.161000+01:00

If you want to develop a custom application in your SAP S/4HANA Cloud Private Edition or SAP S/4HANA system using ABAP Cloud and the 3-tier extensibility model you will need to work with the SAP APIs to access the SAP standard in a clean core compatible way. This blog provides the overview of the relevant sources for looking for the SAP APIs, whereby all sources have the same content.

1. In the ABAP Development Tools for Eclipse

In the ABAP development tools for Eclipse create your own ABAP Repository Tree (context menu New->ABAP Repository Tree on the project node in the Project Explorer), choose "Released Objects" from the list in the Create Tree wizard, click the Next button, enter the name ("Released Objects") and click the Finish button. The Released Objects tree will be added to the Project Explorer:

USE_IN_CLOUD_DEVELOPMENT is valid for S/4HANA Cloud Public Edition
USE_IN_CLOUD_DEVLPMNT_ACTIVE is valid for S/4HANA Cloud Private Edition

(reason: In Private Cloud/OnPremise there are some released APIS assigned to a Public Cloud catalog. They exists but have no functional behavior. ADT will show an error in case you consume them in your custom code)

2. On the SAP Business Acceleration Hub

SAP Business Acceleration Hub is a SAP operated platform to explore, discover and consume APIs, pre-packaged integrations, business services and sample apps from SAP. You can look there for SAP APIs for the relevant SAP S/4HANA product:

SAP S/4HANA Cloud Public Cloud Edition
SAP S/4HANA Cloud Private Cloud Edition
SAP S/4HANA

Please note under Developer Extensibility the you will find details about released APIs for ABAP Cloud. Only the main object types like Behavior Definitions, CDS Views and Cloud BAdIs are displayed including documentation.

3. On the GitHub

The Cloudification Repository on the Github provided by SAP offers you for the SAP S/4HANA products the relevant SAP APIs lists as .json and .csv files:

Cloudification Repository at SAP/abap-atc-cr-cv-s4hc (github.com)

This is a pure technical list to be reused in ATC check for "Cloud Readiness". Besides the released objects (also available on SAP Business Accelerator Hub) additional technical elements like Classes, Authorizations,.. are available. The list is identical to the content in the Repository Tree.
In addition you have access to all deprecated objects, classic APIs, not to be released APIs including successor information.

4. In the Cloudification Repository Viewer

You can use the Cloudification Repository Viewer to access the SAP APIs lists from the Cloudification Repository in the comfortable way:

SAP S/4HANA Cloud Public Edition
SAP S/4HANA Cloud Private Edition 2023 FPS1
SAP S/4HANA Cloud Private Edition - Classic APIs

For details click on a single row to display additional meta data and available successors.
Using the Show Filter Bar button you can choose the relevant SAP APIs list for your SAP S/4HANA product.

4. External tooling

There are also external tools using above mentioned information.

Software-Heroes

Consume Machine Learning API in SAPUI5, SAP Build, SAP ABAP Cloud and SAP Fiori IOS SDK

2024-03-01T11:03:14.858000+01:00

In the current era, machine learning and artificial intelligence dominate the landscape, with a majority of blogs and innovations centered around these transformative technologies. In today’s business landscape, machine learning (ML) and artificial intelligence (AI) play pivotal roles. ML, a subset of AI, enables systems to learn from data and improve performance without explicit programming. The advantages include efficiency, enhanced decision-making, improved customer experiences, fraud detection, and cost savings. Businesses leverage AI for customer service, cybersecurity, content production, inventory management, and more. Looking ahead, strategic AI adoption is crucial for staying competitive and driving innovation .

This blog delves into constructing a straightforward Linear Regression model for predicting house prices using relevant parameters.

To prepare the model, the hana_ml library has used to establish a connection via SAP HANA Cloud and access relevant tables.

Let’s review each step together.

SAP HANA Cloud Setup and Data Upload

Follow the tutorial below to set up an instance of the SAP HANA Database in the BTP Platform.

https://developers.sap.com/tutorials/hana-cloud-deploying.html

Established a fresh Schema and table named “HouseData” using a CSV file containing house details.

Data Upload in HDB using CSV File : https://help.sap.com/docs/SAP_HANA_PLATFORM/fc5ace7a367c434190a8047881f92ed8/d7a79a58bb5710149ed293cc617231b9.html

VSCode Setup and ML Model Development

Visual Studio code (VS Code) is a powerful python editor that offer auto completion, debugging, and seamless environment switching. It simplifies Python development across different platforms, making it a favorite among developers.

VSCode Download : https://code.visualstudio.com/download

Follow the below details and link to setup Jupyter Notebooks in VS Code.

Jupyter Notebook is a proffered choice for python development due to its interactive nature. It allows live exploration, rich documentation combining code and explanations, easy debugging, and widespread adoption in data science and research domain.

https://jupyter.org/

https://code.visualstudio.com/docs/datascience/jupyter-notebooks

Details about the libraries used for creating models and APIs:

HANA_ML https://pypi.org/project/hana-ml/
SKLearn https://pypi.org/project/scikit-learn/
Pickle https://wiki.python.org/moin/UsingPickle
FLASK https://pypi.org/project/Flask/
FLASK_RESTFUL https://pypi.org/project/Flask-RESTful/
FLASK_CORS https://pypi.org/project/Flask-Cors/

Imports of libraries:

Retrieve data from a database table using ConnectionContext, create a linear regression model, and generate a pickle file for future use. The code includes a condition to avoid creating a new model file if one already exists. You can customize the code to adjust the frequency of model file updates based on current database data.

Subsequently, an API built using the Flask library, along with the creation of a model file. The utilization of a request option within the URL facilitated the retrieval of all necessary parameter values. These values are then stored in a payload, which is used to process the model and predict house prices based on various input values.

To address the CORS issue when making requests to the generated API URL from any front-end application, the following approach was employed.

CORS(app, support_credentials=True)

The output following the execution of the API is as follows:

Subsequently, the Business Application Studio application was activated within the BTP platform. The steps for this process are outlined in the following tutorial for the trial plan:

https://developers.sap.com/tutorials/appstudio-onboarding.html#3d3b8693-e86f-4120-8666-25b62797897b

Subsequently, a new development space was established using the “Full-Stack Application Using Productivity Tools” template. Within this space, Python Tools were selected, and additional tools were enabled based on specific requirements.

Given that the API has already been tested and validated with the necessary parameters locally in Visual Studio Code, we can proceed to directly deploy the solution to Cloud Foundry and generate the API.

Provided below are the specifics of the files and the step-by-step process for deploying the solution and creating an API in Cloud Foundry.

In above image below are the file created:

Server.py : This file has same code which has been used in Visual Studio Code.
Runtime.txt :
The runtime.txt file allows you to explicitly specify the Python version that your application should use.
Use below line of syntax to get the installed version of python.
Remember that this file is particularly useful when deploying Python applications to ensure compatibility with the desired Python version.
Requirement.txt :
The requirements.txt file is essential for tracking and managing dependencies in Python projects. It ensures consistent package versions, simplifies collaboration, and facilitates smooth deployment across different environments.
To retrieve the versions of all installed libraries, use the following syntax.
manifest.yml :
The manifest.yml file serves as an essential configuration when deploying Python applications to Cloud Foundry. It acts as an application deployment descriptor, containing crucial information such as the app name, path to the application file, and other relevant settings. By using this manifest, you ensure consistency across deployments, facilitate collaboration, and streamline the deployment process on Cloud Foundry.
Open the terminal (using Ctrl + Shift + `) in Visual Studio Code (BAS). Navigate to project directory using the CD command. Log in to Cloud Foundry by executing the CF LOGIN command, providing user ID and password when prompted.
Next, use the CF PUSH command to deploy the solution to Cloud Foundry as below screen :
After a successful process, the application will be accessible in the application section.
When the application name is chosen, details like application information, instance details, and the most recent application events become visible.
Below is calling of above route with and without using request:
SAPUI5 Application using Created ML API
Utilized the same Development Space to build a basic SAPUI5 application.

In this application, the created API is directly invoked when the user clicks the “Predict House Price” button:

Initially, I considered using the API I created via a destination.

Find below post question :

https://community.sap.com/t5/technology-q-a/how-to-access-destination-from-bas-which-created-using-python-app-deployed/qaq-p/13596319

Upon integrating the created API into the destination, it successfully returns a 200 status response. However, when attempting to utilize the same API within the application, a CORS error occurs.

After thorough analysis, The flask_cors library was instrumental in resolving the CORS error when directly invoking the API within the application. By incorporating this library, the issue was successfully mitigated.

Build App (Web/Mobile Application) using ML API

Created a web and mobile application using SAP Build, leveraging the same API.

Utilized created API following the tutorial below.

https://developers.sap.com/tutorials/appgyver-connect-publicapi.html

The placeholder details for the GET event of API calling are provided below:

Following the configuration of API details, I applied them to the ‘Predict House Price’ button event, resulting in the display of the predicted house price in an alert as shown below:

Consuming API on ABAP Cloud

Developed an ABAP class using the CL_HTTP_DESTINATION_PROVIDER and CL_WEB_HTTP_CLIENT_MANAGER classes. In this class, ensure that all necessary input parameters are provided as importing parameters. The objective is to retrieve house prices as a response using the GET_TEXT method, following the logic outlined below:

To verify the aforementioned logic, the following tutorial was utilized to establish an HTTP service and invoke the method from the developed class within the handle class:

https://developers.sap.com/tutorials/abap-environment-create-http-service.html

When invoking the aforementioned method with the necessary request parameters, the following output will be presented:

Code logic of handle class:

Consuming API using SAP IOS SDK Frameworks

Developed a compact application using XCode IDE and the SAP iOS SDK Framework to interact with the custom House Price Prediction API.

Utilized the SAPURLSession from SAPFramework libraries to invoke the API with all necessary parameters and displayed the predicted house price value in an alert message, as shown in the screenshot above.

https://help.sap.com/doc/978e4f6c968c4cc5a30f9d324aa4b1d7/Latest/en-US/Documents/Frameworks/SAPFoundation/Classes/SAPURLSession.html

Question : Upon configuring the API within the BTP Cloud Application, it becomes accessible from any web browser or software application. Surprisingly, it doesn’t prompt for cloud credentials. kindly suggest any necessary steps to address this access issue?

Git Links:

Referred Links:

https://developers.sap.com/tutorials/hana-cloud-deploying.html

https://help.sap.com/docs/SAP_HANA_PLATFORM/fc5ace7a367c434190a8047881f92ed8/d7a79a58bb5710149ed293cc617231b9.html

https://code.visualstudio.com/download

https://jupyter.org/

https://code.visualstudio.com/docs/datascience/jupyter-notebooks

https://pypi.org/project/hana-ml/

https://pypi.org/project/scikit-learn/

https://wiki.python.org/moin/UsingPickle

https://pypi.org/project/Flask/

https://pypi.org/project/Flask-RESTful/

https://pypi.org/project/Flask-Cors/

https://en.wikipedia.org/wiki/Linear_regression

https://developers.sap.com/tutorials/appstudio-onboarding.html#3d3b8693-e86f-4120-8666-25b62797897b

https://developers.sap.com/tutorials/appgyver-connect-publicapi.html

https://developers.sap.com/tutorials/abap-environment-create-abap-cloud-project.html

https://blog.sap-press.com/how-to-integrate-a-python-app-with-sap-business-application-studio-for-an-sap-s4hana-cloud-system

https://help.sap.com/doc/62a5837b7ce74a92be118efa284c0100/2023_2_QRC/en-US/python_machine_learning_client_for_sap_hana_2.17.230808.pdf

https://help.sap.com/doc/978e4f6c968c4cc5a30f9d324aa4b1d7/Latest/en-US/Documents/index.html

https://help.sap.com/doc/978e4f6c968c4cc5a30f9d324aa4b1d7/Latest/en-US/Documents/Frameworks/SAPFoundation/index.html

Happy Learning 📖 💻

Praveer Kumar Sen

What's new for SAP BTP in February 2024?

2024-03-06T09:26:05.338000+01:00

Welcome to this second iteration of the "What's new for SAP BTP?" newsletter. I got very good feedback from the community for the first occurence, so thanks for the positive comments, and the forwarding in your network.

SAP BTP

My objective with this newsletter is to provide a quick overview what's happened during the month on the BTP area but also highlight the differents channels of information offered by SAP you can use to stay up to date. If you are reading this, you already know this channel, the SAP community 😊, I mainly used as reference on last newsletter. I already mentioned SAP BTP Innobytes, @cecihuergo forwarded me the link to her post where she maintains link to all episodes. You can also use the playlist on youtube and subscribe to the channel to get notification when new video is out. As we talk about youtube channel, you can also check the SAP Developers channel which has a huge content with various format. Last year this channel hosted the Devtoberfest event, and currently DJ Adams aka @qmacro animates livestream on CAP. Let's close this round of table with another medium, podcast, with SAP BTP Talk podcast; we will talk about last episode on the Integration Suite section.

@thomas_volmering provides good highlights on the SAP product stragegy in the developpement, automation and integration areas. It gives a nice overview on how all the new features on the low code/no code suite SAP Build, the new family member SAP Build Code, and the improvement on Integration Suite will help in this strategy and how these solutions are intercomplementary. Finally, IA is the center of discussions for last months, so how to talk about product strategy without mentioning how the generative IA will provide added value on these services.

In the newsletter format, I can also mention the blog post of @Stephanie_Stang on the BTP updates happened on Q42023.

Finally, we close the general update on BTP with the release of the new BTP Repository Diagram.

SAP BTP ABAP environment

Version 2402 has been released this month. As every quarter, lot of improvments, small and big, are there.

@FlorianWahlprovided a detailled inventory of this new release in his blog post. If I would have to highlight only two functionalities, no doubt I will mention the "bring your own Git" functionality which finally offers similar option than the gCTS+ framework on S4/Hana, ie specify your own git repository used to host your software component. Beyond the fact it provides a full control on your source code, I'm pretty sure it will open new options and usages for the community. Second feature is the elastic scaling; after the hibernation last year, the elastic scaling feature is another nice feature to keep the cost under control while using the possibilities of the service at full capacity.

On blog side, @Andre_Fischer posted two interesting blogs on the creation of value help for custom and released domain fixed values which provides an alternative to the original recommandation of using custom view on CDS views DDCDS_CUSTOMER_DOMAIN_VALUE and DDCDS_CUSTOMER_DOMAIN_VALUE_T and on how to reuse access control from a released SAP CDS entity.

Cloud Management Tools

There are lot of visible changes in the services using the BTP, but the platform itself also continously evolves. Most of the time, they are silent because related to technical things behind the scene, but sometimes they are also visible for end user. This month, SAP released a big change in the "Usage Analytics" section of the BTP cockpit which is now called "Cost and Usage": all detail in this blog post.

Integration Suite

The Episode 104 of BTP Talk podcast came back on the announcement of the Edge Integration Cell solution during TechEd last year. The guest of this podcast, @finny_babu, explains in detail what is Edge Integration Cell, what are the use cases, the difference with PO, and how to activate it...

If you prefer reading instead of listening, you can also refer to his blog post published last year.

The International Focus Group for Integration, aka IFG for integration has a monthly event for Integration Suite update. You can find previous sessions and shceduled ones for the year there.

You can find the February session recording here, where you will get updates on API Management, Event Mesh, B2B and a reminder about the upgrade of the outdated third party connector as described in the note 3001980.

Configuration Changes

Note a change is planned in March on the username and domain changes for email notifications sent for SAP Cloud Integration for data services.

Customer & Partner Roundtable for SAP BTP ABAP Environment #11

2024-03-25T19:21:59.111000+01:00

👉 The call for contributions for one of the upcoming roundtables is open!

If you want to show a demo or share a use case scenario for SAP BTP ABAP Environment send us an email and we will get back to you.

Introduction

Meeting Information

When:

April 23rd, 10:00 - 11:00 AM CET – Zoom Meeting (please register in advance)

Who:

All interested customers, partners, and stakeholders are invited to join and exchange ideas and feedback with others and the product team
Steampunk team: Iwona Hahn & Burcu Karlidag (Product Managers for SAP BTP ABAP Environment)
Our guests: Sebastian Werner (Product Manager SAP Fiori elements), Stefan Engelhardt (Architect SAP Fiori elements)

Preliminary Agenda:

Product news & updates
SAP Fiori elements for ABAP developers incl. demo
Q&A

Looking forward meeting you!

Check out our SAP Business Technology ABAP Environment page in SAP Community for product updates and upcoming events.

Customer & Partner Roundtable for SAP BTP ABAP Environment #11

2024-03-27T10:03:34.167000+01:00

👉 The call for contributions for one of the upcoming roundtables is open!

If you want to show a demo or share a use case scenario for SAP BTP ABAP Environment send us an email and we will get back to you.

Introduction

Meeting Information

When:

April 23rd, 10:00 - 11:00 AM CET – Zoom Meeting (please register in advance)

Who:

All interested customers, partners, and stakeholders are invited to join and exchange ideas and feedback with others and the product team
Steampunk team: Frank Jentsch (Product Lead for SAP BTP ABAP Environment),
Iwona Hahn & Burcu Karlidag
Our guests: Sebastian Werner (Product Manager SAP Fiori elements), Stefan Engelhardt (Architect SAP Fiori elements)

Preliminary Agenda:

Product news & updates
SAP Fiori elements for ABAP developers incl. demo
Q&A

Looking forward meeting you!

Check out our SAP Business Technology ABAP Environment page in SAP Community for product updates and upcoming events.

ABAP Matrix (AFM/ALM)

2024-04-05T16:31:45.771000+02:00

Anyone who is on LinkedIn or X/Twitter and reads our posts has probably already stumbled upon the ABAP Feature Matrix project. In this article we want to go into the background, the different variants and the usage.

Introduction

At the DSAG TechXchange we had an exchange with the community and the question came up: "Where can you actually see which features are available in which release?". You will find general information about this everywhere, in the release notes, in blog posts, in SAP examples, but never actually in one place and clearly assigned to a release. The idea then developed to create an overview of all features that are relevant for the ABAP developer.

Development

The first version of the matrix started as a simple list on our website and was still quite complex to maintain. We put the appropriate crosses in a table.

First version of the ABAP Feature Matrix

But what about the next release? Here we would have to add a column and fill the column for all existing features. Maintaining and moving it is also not that easy and we cannot correct mistakes so easily. The community then asked why not make the data available via GitHub? Since then, all matrix data has been stored in JSON format in our GitHub repository.

Overview of the GitHub Repo

ABAP Feature Matrix (AFM)

The ABAP Feature Matrix (AFM) is the first prototype that is intended to display all features from version 7.40 to today in an overview. As of this release, we actually speak of Modern ABAP, as the ABAP language has developed and modernized significantly since then. These features are mapped according to the different groups, the information about them is pulled from the different configurations of GitHub.

Filter

Before the matrix is loaded, you have the option to make restrictions to influence the result and structure. Do you want to see all releases or just a specific one? Do you also want to see all categories or, for example, just the Core Data Service features? If you want to export the document, you may not need a table of contents; by default this is generated for easier navigation.

Filter of the AFM

Overview

Once the matrix has loaded, you will see all features displayed in several tables.

Example overview

The tables are always structured the same way, from left to right:

Feature - The ABAP keyword or a short description of the feature the line is about.
Wiki - A link to the description on GitHub, where you can find more information about the feature, at least one link to public SAP documentation and perhaps a short example.
SAP Documentation - The direct link to the documentation on SAP Help or to an SAP blog. What is important to us here is that there are links to official documents.
Release - Listing of the different releases and whether the feature is available in this on-premise release. You will also receive information about obsolete things and features that were later made available for older releases.

Usage

The feature matrix is intended to give you a quick overview of all the features across the various releases and at the same time quick access to all important information. In the Wiki area you will find a description, a link to official documents, a possible example and possibly further information if a downport is available and where you can find further information. Here's an example from the wiki:

Example documentation

ABAP Learning Matrix (ALM)

When developing the feature matrix, the idea of the ABAP Learning Matrix (ALM) also came up, because as a developer you are probably also interested in which features are available and new after a release change.

Filter

You can use the filter to enter your current release and the new release so that the system can determine the features.

Filter of the ALM

Overview

You will then receive a table with the Delta features, the category and links to the documents. The data from the ABAP Feature Matrix serves as the basis for creating the list.

AFM output

Usage

Are you currently making a transformation towards HANA or a release change to S/4 HANA 2023? The matrix is intended to give you an overview of the relevant features that are being added. At the same time, you have the opportunity to skim through the new functions at a glance and pick up the most relevant things for yourself.

Data sources

We are currently using various data sources to collect all information, and we primarily want to use official and confirmed information. Current documents are therefore:

Open Source

We make all information freely available in a structured manner. You can use the information freely, but we would also be happy if you collaborate on the project. Are you missing information about certain features? Did you find any errors in the matrix? Then you can send us information, open an issue or participate directly in the project.

If you want to know more about the structure of the repository, you can find more information in the project documentation, where we explain the structure and contents.

Conclusion

The ABAP Feature Matrix is not yet complete and perhaps never will be. But it already gives you a good overview of many features across the various releases.

CDS View: Hierarchy node sign reversal

2024-04-15T13:30:04.285000+02:00

This blog is about how to use @Semantics.signReversal in CDS Views to revert the sign of a measure in dependence of the settings of a hierarchy node. Analytic query offers the functionality to reverse a sign after aggregation based on a hierarchy node attribute.

This functionality shall be made accessible from a CDS Query, for this it is necessary to determine the hierarchy node attribute which stores the sign reverse indicator.

To make use of the sign reversal feature in an analytical query, the following field needs to be added to the related hierarchy view:

@Semantics.signReversalIndicator

signref as signReversalFlag,

Example: Hierarchy view

@AbapCatalog.sqlViewName: 'ZOQ_CONNIDHIER'
@EndUserText.label: 'Connection Hierarchy View'
@ObjectModel.dataCategory: #HIERARCHY
@Hierarchy.parentChild : {
  name : 'ConnectionHierarchy',
  label : 'Connection',
  siblingsOrder: [{ by: 'seqno' , direction: 'ASC' }] ,
  recurseBy : '_parent',
  directory: '_dir'
}

define view ZOQ_CONNECTION_HIERARCHY
  as select from zoq_connid_h

  association [0..1] to ZOQ_CONNECTION_HIERARCHY     as _parent     on  $projection.parentid = _parent.nodeid

  association [1]    to ZOQ_CONNECTION_HIERARCHY_DIR as _dir        on  $projection.hieid = _dir.hieid

  association [1]    to ZOQ_CONNECTION_NODENAME as _node       on       $projection.hieid   = _node.hieid
                                                                    and $projection.nodename = _node.nodeName
                                                                    and $projection.carrid   = ''
                                                                    and $projection.connid   = '0000'

  association [1]    to ZOQ_AIRLINE                  as _airline    on  $projection.carrid = _airline.carrid
                                                                    and $projection.connid = '0000'

  association [1]    to ZOQ_CONNECTION               as _connection on  $projection.carrid = _connection.carrid
                                                                    and $projection.connid = _connection.connid

{
      @Consumption.filter: { mandatory : true, selectionType : #SINGLE, multipleSelections : false }
      @ObjectModel.foreignKey.association: '_dir'
  key hieid,
  key nodeid,
      parentid,

      seqno,

      @ObjectModel.foreignKey.association: '_airline'
      carrid,
      @ObjectModel.foreignKey.association: '_connection'
      connid,
      @ObjectModel.foreignKey.association: '_node'
      nodename,
      
      @Semantics.signReversalIndicator
      signref as signReversalFlag,

      _parent,
      _dir,
      _node,
      _airline,
      _connection

}

Preview:

In CDS views with "Analytics.query : true" or define as "transient view entity", function "HRY_NODE_SIGN_VALUE(elemRef)" is used in a formula (AnalyticsDetails.query.formula). This function works in the following way, At first the path from the element to its hierarchy view is evaluated. In the hierarchy view there should exist exactly one field with semantics signReversal. For each hierarchy node for which the value of the sign reversal element returns space, the function HRY_NODE_SIGN_VALUE will return +1. If the value is not initial, the function returns -1. With this,

for example- the formula $projection.paymentsum * hry_node_sign_value( dimension => $projection.connid) as paymentsumSignRef

will return the key figure paymentsum for all nodes/leaves in the hierarchy with initial sign reversal indicator and It will return "- paymentsum" for all nodes/leaves with not initial sign reversal indicator.

If there is no field with semantics signReversal in the hierarchy view, the function HRY_NODE_SIGN_VALUE always returns +1.

Example: Analytical query

@AccessControl.authorizationCheck: #NOT_ALLOWED
@EndUserText.label: 'SIGN REVERSAL'
@Metadata.ignorePropagatedAnnotations: true
define transient view entity ZLR_SIGN_REV_FLIGHT_1 
   provider contract analytical_query 
     with parameters
     @EndUserText.label: 'Hierarchy'
     @Consumption.defaultValue: 'CNTRY' 
     p_hienm : char5 
     
  as projection on ZOQ_FLIGHT
    
 {   
    @AnalyticsDetails.query.axis: #ROWS
    @AnalyticsDetails.query: {
      displayHierarchy: #ON,
      hierarchyBinding: [{ type : #PARAMETER , value : 'p_hienm' }]
    }  
    connid,
    @AnalyticsDetails.query.axis: #FREE
    currency,
    
    @Semantics.amount.currencyCode: 'CURRENCY'
    @Aggregation.default: #SUM
    @AnalyticsDetails.query.axis: #COLUMNS
    curr_to_decfloat_amount( paymentsum ) as paymentsum,
    
    @AnalyticsDetails.query.axis: #COLUMNS
    @EndUserText.label: 'HierSignRev'
    @Aggregation.default: #FORMULA
    $projection.paymentsum * hry_node_sign_value( dimension => $projection.connid) as paymentsumSignRef
  
}

Result:

In this example for Hierarchy ZOQ_CONNECTION_HIERARCHY (which is defined in the ZOQ_FLIGHT), signReversalFlag is set for Carried id 'A', 'JL', 'UA'. Therefore, in result of analytical query HierSignRev field is showing the –ve result of the booking total.

SAP Delivered Hierarchies:

There are few SAP delivered hierarchies which have this feature.

Following fields name: FinancialStatementItem, CnsldtnFinancialStatementItem, FinancialStatementLeafItem, GLAccount, etc.

Can have this feature because they have foreign key association with dimension view which has hierarchy association to hierarchy view supporting this feature.

For example: Field with name ‘FinancialStatementItem’ typically have a foreign key association to dimension view I_CnsldtnFinStmntItem and corresponding hierarchy view I_FinStmntItmHier will support this feature.

Constraints:

Only one element in a view of data category HIERARCHY can be marked with semantics signReversal. The data type of the element should be CHAR of length 1. Allowed values are X or space.

Related Note:

1385580 - How does a formula variable with a replacement path work?

Availability:

This feature is available from S/4HANA 1909 (ABAP Platform 7.54).

Capture Your Own Workload Statistics in the ABAP Environment in the Cloud

2024-04-18T13:02:05.620000+02:00

As an administrator in SAP BTP, ABAP environment or in SAP S/4HANA Cloud ABAP Environment, it’s important to keep track of performance issues and identify bottlenecks. Now SAP offers a few Fiori apps to help you with monitoring the system workload. However, relying on what data the system automatically collects for you sometimes isn’t enough.

Instead, you want to define yourself what kind of workload information is captured, such as in the following use cases:

Standard apps and tools show you that there’s a high workload, but when you drill down to details, you don’t get the information you’re interested in.
You want to monitor the workload of a clearly defined special case, such as the workload generated by a user or by one of your custom apps (which you might want to watch using its request entry point).
You have specific requests where you want to get alerted when the workload, for example, exceeds a defined threshold.

In this blog post, I’ll show you how to use the Capture Request Statistics app to cover these use cases.

Background: the System Workload App

Before I introduce you to the Capture Request Statistics app, let me start with a brief recap of what the System Workload app can do for you out of the box (for more details, see the blog post Analyzing performance degradations in the ABAP environment in the Cloud).

Let’s say you want to analyze the performance of your ABAP system in the System Workload app:

System Workload app

You find the top resource-consuming application in the system and want to analyze it further. You can analyze this application in more detail by choosing the Details arrow at the end of the row. In the following screen, you typically find samples of single ABAP statistics records for this workload. Now, how are these ABAP statistics records collected by default and how can you influence what is captured? Let's take a look behind the scenes.

Default Configuration: Capture Workload Statistics with Static Thresholds

An ABAP Environment in the Cloud comes with pre-delivered SAP profiles that capture ABAP statistics records in your system. You can find these pre-delivered SAP profiles in the Capture Request Statistics app:

Pre-delivered SAP profiles

These profiles ensure that the statistics about “bad” requests - meaning a high consumption of compute resources – are captured in the system. If you look, for example, at the details of the static profile for expensive requests regarding server response time, you find a static threshold of 1 second:

Pre-delivered SAP profile - capture requests with high server response time

With this profile always active, ABAP statistics records with an ABAP server response time larger than 1 second are captured and stored. Similarly, the other pre-delivered static profiles capture requests that exceed 1 second regarding HANA CPU time, ABAP CPU time, etc.

In the profile header, you can find that for the SAP-delivered profiles, a sampling rate of 1% has been set. It means that only 1% of the records that fulfill the filter condition will be captured. In addition, the record limit per minute is set to 50. The periodic data collector that runs every minute and processes the ABAP statistics records (together with the profiles in the Capture Request Statistics app) will only store the ABAP statistics records up to this limit in the database. So, if many ABAP statistics records fulfill the filter condition at a time, not all of these records will be stored.

For SAP-delivered profiles, this low record limit per minute together with the low sampling rate ensures that the workload and data footprint for processing and storing monitoring data in your system stay low, even if the overall business workload on the system gets exceedingly high.

Default Configuration: Capture Workload Statistics Dynamically

In addition to the pre-delivered static profiles, the dynamic SAP profile SAP_DYNAMIC_CAPTURING ensures that for the top workload of your system “good” statistic samples of requests are also captured (with respect to the server response time). As a result, you can compare statistics of samples of “bad” workload to statistics of samples of “good” workload. The top workload in your system might vary as well as the behavior in response times. The dynamic profile adapts to these changes.

In addition, for the top workload, the dynamic profile captures samples of ABAP statistics when their server response times deviate too much from the average server response time of this specific kind of workload. This ensures that for workloads with typically different server response times, samples of ABAP statistics records are also at hand, even if their server response times do not exceed the static thresholds of the static profile types.

In principle, the pre-delivered static profiles together with the dynamic profile will give you a high chance that for your top workload, you’ll find samples of ABAP statistics records in the system that you can use for detailed analysis. You get this data using the System Workload app and by drilling down to the ABAP statistics records, and in most of the cases, that’s enough. However, as these statistics are sampled, it might happen that sometimes you don't find any records that you can use for further analysis:

System Workload app - no detailed statistics available

To have these detailed statistics for your root cause analysis, you can capture your own workload statistics in your ABAP environment in the Cloud.

Capture Your Own Workload Statistics in the Capture Request Statistics App

You can create your own capture profiles, of course. While the SAP profiles are designed in such a way that they capture samples of ABAP statistics records for generic expensive workload in the ABAP tenant, you might want to specify the workload more concretely. For example, you might be interested specifically in the ABAP statistics records of your user or of a certain outbound communication arrangement. Or you might be interested in workload that exceeds a specific threshold (as in the pre-delivered SAP profiles). To do so, you can create your own capture profile.

If, for example, you have built a new ABAP RESTful application for travel bookings, you could define a profile that filters on its specific request entry point (consisting of request entry name and request entry type):

Custom profile

A custom profile is in status Inactive when newly created. If you click on the Activate button, the profile status will be set to status Processing, and only then will the data collector process ABAP statistics records that fulfill the defined filter conditions. On activation of the profile, you also need to specify the duration of how long the profile should be active. When the duration is exceeded and all the relevant ABAP statistics records are processed, the profile will be set to status Finished and no further ABAP statistics records will be processed for this profile.

In the example profile shown here, a sampling rate of 100% and a record limit per minute of 1000 has been set. Both are the maximum possible values. This setting guarantees that all ABAP statistics records fulfilling the filter conditions are captured. Of course, if the record limit of 1000 is exceeded, you won’t capture everything. But this happens only in rare cases. In any case, it’s ensured that also for a badly designed capture profile, your business is not impacted by the additional workload of capturing request statistics.

The target user group in the profile header indicates that only workload is considered that is running in customer user context. You can specify this further by considering, for example, only customer communication users or customer business users.

If the profile is active and users are performing actions in your ABAP RESTful application, the according ABAP statistics records are captured and stored in the database for a period that you have defined in the retention time of your profile.

For further analysis, e.g., the performance of a new app that you have built, you can navigate to the captured ABAP statistics records by clicking on Analyze Request Statistics. There you can analyze the captured single ABAP statistics records in detail and obtain insights into the behavior of your newly created app:

Analyze ABAP statistics records in detail

You can find more information, for example, about SQL statements or, in the case of communication, about HTTP calls by choosing the Details arrow at the end of a row, which leads you to the details of that ABAP statistics record.

If your new application belongs to the more expensive workload in the system, you’ll easily find the captured ABAP statistics records also in the System Workload app. There, you start from the overall workload (aggregated ABAP statistics records) of your business tenants. If you drill down to the details of your application, you will get to the ABAP statistics records. Your custom profile ensures that they have been captured:

System Workload app - detailed statistics available

Note: With the Capture Request Statistics app, you can also define profiles with profile type SQL Trace. With these profiles, you can trace the execution of SQL statements. These captured SQL statements can be further analyzed in the SQL Trace Analysis app. This might be another story for another blog post in the future, so stay tuned.

You can find more information about the Capture Request Statistics app in the following documentation:

Getting Notified About Specific Workloads

You may have noticed that by defining a custom capture profile for capturing ABAP statistics records, you can set the option for Health Monitoring. If you have connected your SAP BTP, ABAP environment or SAP S/4HANA Cloud ABAP Environment tenant to SAP Cloud ALM, you’ll receive a counter per capture request statistics profile in SAP Cloud ALM for Operations in the Health Monitoring app. You can find more information on how to connect your tenant to SAP Cloud ALM here:

For our custom profile example Z_STATIC_PROFILE, you’ll find the tile Captured ABAP Statistics Records in the Health Monitoring app in your connected SAP Cloud ALM tenant. If you click on the tile for details, you find your custom profile together with a counter

SAP Cloud ALM - Health Monitoring

This counter is normalized to 5 minutes. This means that during the last 5 minutes, 27 ABAP statistics records were captured in your ABAP tenant that fulfill the filter conditions that you have defined in your custom profile. Besides this usage scenario, you can also use the Health Monitoring feature on capture profiles with static thresholds (like in the case of the pre-delivered static SAP profiles) to count how often your defined thresholds are exceeded. For more information, see also the blog post Monitoring the Performance of Outbound Communication in the ABAP Environment in the Cloud.

If you want to get alerted by email when the filter conditions of your profile are hit a certain number of times, you can configure alerts in SAP Cloud ALM in the Health Monitoring app. For more information, see the blog post Monitoring the Health of the ABAP System in the Cloud.

Summary

The default configuration of your SAP BTP, ABAP environment or SAP S/4HANA Cloud ABAP Environment tenant comes with pre-delivered SAP profiles that capture ABAP statistics records for the most important workload in your system. This helps you analyze and understand your system workload in detail.

However, if you want to enhance this default configuration, you can do so by creating your own profiles using the Capture Request Statistics app. The monitoring data collector ensures that requests that fulfill your filter conditions are captured and stored in the system for further analysis. You can define profiles for capturing ABAP statistics records and for capturing SQL statements.

Let’s quickly recap in which use cases creating your own profiles in the Capture Request Statistics app is useful:

In your standard system-local analysis of the system behavior, detailed statistics are missing for a certain workload that you need to have at hand.
You want to proactively capture extensive details for a workload of your choice to analyze it in detail.
In SAP Cloud ALM, you want to understand how often your workload in the landscape hits certain criteria (= your filter conditions defined in the profiles), and you want to get alerted in this case

I’d like to thank everyone who contributed to this blog post, especially my colleagues @anke_griesbaum, @Karen_Kuck, @SabineReich, and @steffen_siegmund.

Let me know in the comments if and how you’ve used the Capture Request Statistics app and what you think of it.

ABAP Cloud Developer Trial 2022 Available Now

2024-04-19T18:52:59.860000+02:00

Dear all,

ABAP Cloud Developer Trial 2022 is now available on Docker:

https://hub.docker.com/r/sapse/abap-cloud-developer-trial/tags -> 2022

ABAP Cloud Developer Trial is a free, downloadable ABAP Platform on SAP HANA 2.0 for trying out the ABAP language and toolset. It is extensively pre-configured with SAP Fiori launchpad, SAP Cloud Connector, pre-configured backend /frontend connections, roles, and sample applications.

This solution is intended for two groups of developers:

Non-ABAP developers, who are interested in learning more about the ABAP language and development tools
ABAP developers, who are interested in learning about new features (see below for some examples)

Note: This is the new name for ABAP Platform Trial. The name change is to highlight that you can now develop in the new ABAP Language Version, ABAP for Cloud Development. For more information, see the Highlights below. By the way, if you are interested in our overall release strategy for the Trial, see Karl Kessler’s announcement blog post from 2023: Now available: ABAP Platform Trial

IMPORTANT:

All: Before you pull the image, make sure:

You understand the principles of docker container technology
You know the entities docker image / docker container and their relationship
You know the basic commands to work with images and containers

Mac Users: Previously, ABAP Platform Trial ran on both Intel and M-series processors. Since then, Apple has upgraded its iOS. Thus, on the newest MacOS version, you can no longer run ABAP Cloud Developer Trial on Docker Desktop for MacBooks with an M-seríes processor. This is not a SAP-specific issue. So for now, you have two options:

Run Docker Desktop with a MacBook that has an Intel processor.
Use the UTM app to emulate an AMD64 Linux distro via Apple QEMU.

Many many thanks to Community member @dylan-drummond for researching this. Dylan has written an exhaustive guide to this:

M-series Apple Chip MacBooks and Abap Platform Trial containers using Docker and Podman

This is Community content, so consume at your own risk; however, this could be very helpful to many Mac users.

ABAP License

The ABAP license supplied with the Docker image lasts only three months. Therefore, you should download and import the demo license as follows:

Logon to your ABAP system with the user SAP*, client 000, same password as for DEVELOPER (DEVELOPER , client 001, is locked).
Start transaction SLICENSE; copy the hardware key.
Get the license from minisap , choosing the system A4H.
Back in your ABAP System, log off, then log on with the user DEVELOPER, client 001.
Choose Install.
The old ("INITIAL") license(s) should be deleted automatically. If not, start SLICENSE again; remove the old invalid licenses. (sap* is not allowed to delete licenses).

Update, 23rd April, 2024: 2022 as a Cloud Appliance (CAL)

Dear all, As an alternative to the Docker download, we have also released the same version of the Trial, under the name SAP ABAP Platform 2022, Developer Edition:

https://cal.sap.com/catalog#/applianceTemplates/c12a3b3d-99b0-4b44-a0c7-6509fe279a3d

Enjoy!

Highlights of the 2022 Edition

ABAP Cloud Development: Developer Extensibility Scenario

ABAP Cloud map

ABAP Cloud is the ABAP development model you need to build cloud-ready business apps, services, and extensions. Including it in the ABAP Cloud Developer Trial means that you can get a feel for the concepts pertaining to ABAP Cloud Development and to a clean core when extending SAP S/4HANA. This scenario lets you build extensions directly on the SAP S/4HANA stack - tightly coupled, cloud-ready, and upgrade-stable. Of course, we don't offer the strictly business content from SAP S/4HANA. However, we do offer all the language elements - RAP cloud-optimized language, and released APIs and extension points.

Important: You are thereby restricted to cloud-optimized ABAP language. That is, if you are used to developing in Classic ABAP on-premise, and want to try out Cloud development, you must comply with ABAP Cloud Development rules, such as:

Use public SAP APIs (local or remote) released by SAP to access SAP functionality and SAP data
Use public SAP extension points released by SAP to extend SAP objects. Modifications to SAP objects are not supported. (This includes SFLIGHT, for example.)
Use ADT (ABAP Development Tools) as your ABAP IDE
Use RAP (ABAP RESTful Application Programming Model) to build Fiori apps and services. SAP technologies like Dynpro or Web Dynpro are not released for ABAP cloud development
The software components ZLOCAL and ZCUSTOM_DEVELOPMENT can only be used for ABAP Cloud development - that is, compliant with these rules

More information:

ABAP RESTful Application Programming Model (RAP) - 2022

Offers you an efficient way to build enterprise-ready, SAP HANA-optimized, OData-based Fiori UI services and Web APIs in the cloud as well as on-premise.

New features in 2022 include:

Custom business objects
Event Consumption and Exposure
RAP Generator
RAP business object Test Double Framework (TDF)

To make it easier for you to get started, we have also added:

The demo and training data model, the ABAP Flight Reference Scenario (or directly: ABAP Flight Reference Scenario 2022 on github)
The SAP Fiori Element Feature Showcase App for RAP

More information:

Git-Enabled Change and Transport System (gCTS)

gCTS = CTS + git

A new way of transporting objects, gCTS enables you to use Git to store your ABAP development objects. gCTS makes use of special Git features, such as working on local copies of a central remote Git repository. Software development takes place in the usual editors like ABAP Development Tools (ADT). Changes to objects are still recorded in transport requests. Current states of objects can be pushed to remote Git repositories, either by releasing a transport request or while you’re working.
For the official documentation overview, see:

Git-Enabled Change and Transport System (BC-CTS-GIT) | SAP Help Portal

The official documentation for configuration is in two parts:

Configuring Git-Enabled Change and Transport System
Here, we have preconfigured the first two parts, so you only have to complete parts 3-5:
Configuring Git Repositories

Some certificates are already available. If you would like to connect to your own GitHub server or to a provider other than github.com, you have to add the appropriate certificates to the ABAP system in transaction STRUST. The configuration has been done for the default user ‘DEVELOPER’.

To get started with gCTS, simply open the gCTS app in the SAP Fiori Launchpad (FLP).

If you are a SAP customer, partner, or employee, the following SAP Note provides additional information: SAP Note: 2821718 . However, the essential configuration has already been done for everyone.

abapGit

Yes, abapGit is available out of the box.
Documentation is here: abapGit Documentation
If you are not yet familiar with abapGit, this post by graham.robinson is a great introduction, with how-to videos:
abapGit So Easy

Custom Code Migration with the ABAP Test Cockpit (ATC)

We've pre-configured ABAP Platform Trial to run as a central check system for checking your custom code prior to migration - particularly useful for:

SAP S/4HANA Readiness Checks
SAP Cloud Readiness Check

You can test this out of the box locally in SAP ADT, then configure the rest of your landscape to work with it.
For more general information on ATC, see these two excellent blogs, by Olga Dolinskaja:

SAP Cloud Connector

SAP Cloud Connector provides a link between SAP Business Technology Platform (BTP) applications and on-premise systems. It runs as on-premise agent in a secured network; acts as a reverse invoke proxy between the on-premise network and SAP BTP; and lets you use existing on-premise assets without exposing the entire internal landscape.

If you are interested in connecting your ABAP Platform Trial with a licensed version of SAP BTP, ABAP Environment (i.e.“Steampunk”), I have written a tutorial mission on this: Connect Your On-Premise System with SAP BTP, ABAP Environment

For more information, see:

SAP Help Portal, SAP BTP Connectivity: SAP Cloud Connector
SAP Community blog post (third-party content): SAP BTP Cloud Connector – A Brief Guide for Beginners

Other Highlights of ABAP Platform 2022: Overview

Blog post: ABAP Platform for SAP S/4HANA 2022, from November 2022, by Olga Dolinskaja, including the Overview Presentation

Guides, Tutorials, FAQ, Troubleshooting

If you’re not sure where to start with your new system, we have written several tutorials:

SAP Tutorial Navigator: ABAP On-Premise Tutorials.

I have started putting together FAQs specifically for ABAP Platform Trial / ABAP Cloud Developer Trial on Docker. If you would like to contribute to this, please let me know:

ABAP Trial Platform on Docker: Tips and Tricks

The old FAQs also contains some non-release-specific info on Cookbook-style projects, by SAP Community members: I will

FAQ and Troubleshooting for SAP AS ABAP 7.5x

Troubleshooting: One last thing: Now that comments are no longer threaded, it is almost impossible to keep track of / answer your troubleshooting / error questions. Please please create a new question in the SAP Community - ABAP Development forum (which uses the User Tag "abap_trial"). I will try to monitor these questions, but other experienced ABAP users / mentors will also see them.

Enjoy!

Customer & Partner Roundtable for SAP BTP ABAP Environment #12

2024-04-24T20:33:53.136000+02:00

👉 The call for contributions for one of the upcoming roundtables is open!

If you want to show a demo or share a use case scenario for SAP BTP ABAP Environment send us an email and we will get back to you.

Introduction

Meeting Information

When:

May 23rd, 10:00 - 11:00 AM CET – Zoom Meeting (please register in advance)

Who:

All interested customers, partners, and stakeholders are invited to join and exchange ideas and feedback with others and the product team
Steampunk team: Frank Jentsch (Product Lead for SAP BTP ABAP Environment), Anne Keller (Chief Development Experts ABAP Cloud Dev Tools), Thomas Alexander Ritter (Area Product Owner ABAP Cloud Dev Tools), Iwona Hahn & Burcu Karlidag (BTP ABAP Product Manager)

Preliminary Agenda:

Product news
New features of 2405 release
E2E Developer Experience for ABAP Cloud incl. demo
Q&A

Looking forward to meeting you!

Check out our SAP Business Technology ABAP Environment page in SAP Community for product updates and upcoming events.

SAP BTP, ABAP in the Cloud Custom Code Transformation using abapGit and gCTS

2024-04-26T09:09:05.666000+02:00

abapGit and gCTS (Git-enabled Change and Transport System)

The basic idea behind abapGit is to exchange source code between any ABAP systems using a Gitbased repository.

By introducing gCTS, SAP is aiming for the best of both worlds, that is, repository-based
development where concurrent work on the same object is possible, while retaining all the benefits of
central development.
Following is the process flow for gCTS.

You can use gCTS to distribute your custom code through a central repository, which will enable
possible rollbacks before importing to the target system, if required.
You can possibly use abapGit to move your on-premise ABAP objects to SAP BTP, ABAP
environment. In the next section, we’ll demonstrate how to use abapGit to move ABAP objects from
your SAP S/4HANA on-premise environment to SAP BTP, ABAP environment.

Custom Code Transformation Using abapGit

Transforming on-premise ABAP code to SAP BTP requires three primary steps.
- Evaluating current code.
- Installing abapGit.
- Transforming code.

Evaluation of On-Premise code for Compatibility

Make sure that your code is using the ABAP for SAP BTP language version (ABAP for SAP Cloud
Platform).
Once the language version is changed, execute ATC check or transaction SCI to check for any issues.

Installing abapGIT on an On-Premise and as an Eclipse Plugin

On-Premise

Create a new repository on GitHub.

Give a name to the repository and click the “Create Repository” button

Visit https://github.com/abapGit/abapGit and click on the latest build as follows. This simply has the
code for an ABAP report program.

Create a report program on your on-premise SAP system and copy the code you see above into the
program and activate.

The following screen should appear once you execute this program

abapGit has now been installed on the on-premise system

As an Eclipse Plugin

Open ADT->Help->Install new software and enter the following URL to load abapGIT for ABAP
development on ADT.
http://eclipse.abapgit.org/updatesite/
Simply click on “Next” and install the plugin

Transform code form on-premise to cloud

Visit your GitHub repository and copy the URL corresponding to your repository.
Go back to your ABAP report program on the on-premise system, Click new online.
Paste the URL you copied above to the following location, along with the package that you want to
commit to the Git Repository you created above. This is the package that is in your on-premise
system, which you want to migrate to the cloud environment.

Click on “Create Online Repo”.
Once the execution is completed, you should see the cloned repository as follows, which is ready to
be committed to the online Git Repository.

Now click on “stage” and “commit all changes” to the online repository

Give a comment for the commit that you do each time as follows. Click on “Commit”

This will request for your GitHub credentials, to authenticate. Give them and Continue.

Once the commit is complete, you should see a message as follows

And the source code under the package should be available in your online Git Repository.

Open ADT on Eclipse-> Select Your ABAP in the cloud Project -> Window -> Show -> Other ->
abapGit Repositories.
Click the “Plus” button to link your abapGit Repository to ADT. Give the URL corresponding to your
Git Repository here as well.

Create a package in your ABAP in the cloud project, to which you will be importing all the supported
objects in your on-premise ABAP package. Here I have given the same package name.
Make sure to put the “Pull after link” tick as well, so the objects will be pulled from your online Git Repository into ABAP in the cloud project.

Once that is completed, you should see all supported objects on your on-premise system, imported
into your ABAP in the cloud package.

Get started with SAP BTP ABAP Environment: Trial Account vs. Free Tier Option

2024-04-26T15:24:35.800000+02:00

Understanding the various Try and Buy options is crucial in exploring the SAP BTP ABAP Environment, ensuring an easy start to your journey. Let's take a closer look at the two tryout options:

Trial Account

The SAP BTP trial allows you to experiment and educate yourself and get familiar with the SAP BTP ABAP Environment. The instance is shared between all trial users. This shared trial offering allows users to share an instance, where all development objects are visible and editable by other trial users. You agree not to upload any personal data, any confidential information of you or your company, or use the service for a productive environment. By default, the trial account lasts for 30 days but can be extended up to 90 days. After this period, the instance is automatically deleted, and a seamless transition to a paid standard version isn't feasible. Due to the shared instance approach, a few features like connectivity are not supported. Please find more information in this blog post.

Free Tier Option

Designed for small proof-of-concept projects, the free tier option offers exploration of all capabilities for non-productive scenarios over a fixed 90-day trial period. It can also be utilized for piloting remote ABAP Test Cockpit (ATC) scenarios against on-premise systems in the Custom Code Migration App. Unlike the trial version, each user has their own instance. A seamless transition to the paid standard plan is supported within the trial period, without data loss. After 90 days, the instance is automatically deleted.

Selecting the appropriate choice

To choose the right option between the trial account and the free tier option, consider your specific needs and goals:

Category	Trial Account	Free Tier Option
Purpose	Experimentation, educational purposes	Small proof-of-concept projects, non-productive scenarios
Feature Set	Limited	Not limited
Duration	Extendable up to 90 days	Fixed 90-day trial period
Data Privacy and Security	Shared instance	Individual instance
Seamless Transition	Not possible	Possible

Please evaluate these aspects and consider your future beyond the trial period to determine which option aligns best with your needs.

How to generate a wrapper for function modules (BAPIs) in tier 2

2024-05-06T16:10:39.975000+02:00

Introduction

In a tutorial Implement a Wrapper for the "Create Purchase Requisition" (BAPI_PR_CREATE) function module that was published recently it was shown how to deal with the case in which no convenient released API is available to create purchase requisitions.

The question that came to my mind was whether there would be a way to automate the steps described in this tutorial so that creating wrappers for other BAPIs would become more easy.

So I did some investigation and have build a prototype of such a wrapper that it based on the same framework as the transaction ACO_PROXY.

This transaction is already available for quite some time and can be used to generate a wrapper class for one or more function modules.

In order to leverage the generated code it would however be necessary to perform several manual steps to adapt the same. Since these steps can be automated I have build a helper class and a helper report that perform these tasks for your convenience.

RFC tier2 proxy generator

The RFC tier2 proxy generator is based on the same API that is used by the transaction ACO_PROXY which is described in the following tutorial. This transaction allows to generate a wrapper class for one or more function modules. The code can however not be used immediately since it contains a few statements that need to be adjusted (e.g. CLASS-METHODS statements and CALL DESTINATION _dest_ statements).

The transaction ACO_PROXY and its underlying API now also check if a data element that is used by a non released function module itself has been released. If this is the case, no shadow type will be generated.

The recommended approach (see the tutorial above) is also to use a C1-released interface and a C1-released wrapper class that intantiates the wrapper class being used in your ABAP Cloud coding.

So I developed a class that calls the same API

cl_aco_static_proxy=>create_static_proxy_by_rfc(
               EXPORTING
                 function_names         = i_function_modules
                 proxy_name             = i_proxy_class_name
                 destination_name       = 'NONE'
                 devclass               = i_package_name
                 trkorr                 = i_transport_request
                 classic_exceptions     = abap_false
                 bapi_exceptions        = abap_false
                 generate_inactive      = abap_false
                 destination_by_constructor = abap_false
                 do_not_create_released_type = abap_true
             ).

and which in addition

creates an interface and a factory class
moves part of the code generated by the API mentioned above to the interface
changes the code of the generated wrapper class to use the interface
C1-release the factory class and the interface

How to get the source code of the RFC tier2 generator

The source code of the RFC tier2 generator has been published in the following repository on Github.com

SAP-samples/tier2-rfc-proxy

Prerequisites

- You have to have a system based on SAP S/4HANA 2022 or 2023 on premise.
- You have to have enabled Developer extensibility
- You have to apply the following notes
- [SAP Note 3444292 - ACO Proxy creates unnecessary shadow types](https://me.sap.com/notes/3444292)
- [SAP Note 3457580 - SAP ACO - Duplicate Types for Table Parameters](https://me.sap.com/notes/3457580)

How to use the RFC tier2 generator

When you have downloaded the class and the report simply start the report zr_gen_rfc_tier2_proxy.

Here you can select one or more function modules that will be wrapped by one single class.

(e.g BAPI_PR_CREATE, BAPI_PR_CHANGE, BAPI_PR_GETDETAIL, ...)

Now you have to specify additional parameters such as the target package where the wrapper objects are going to be generated.

Then there there are two radio buttons that allow you to choose between the generation of an interface, a wrapper class and a factoy class (option 1, recommended) or just one wrapper class (option 2).

As described in the above mentioned tutorial the approach of using an interface and a factory class is the recommended one.

Last not least you have to provide the names of the repository objects that will be generated.

When the reports finishes successfully it will list the generated repository objects.

The objects can then be checked in the target package.

Hope this will help to speed up the process of creating wrappers for non-released function modules.

ToDo's

What is left to do is to change the value help of the report such that only function modules can be selected that are marked as stable.

How to find SAP APIs for SAP S/4HANA 3-tier extens... - SAP Community

SAP/abap-atc-cr-cv-s4hc: ABAP test cockpit cloud readiness check variants for SAP S/4HANA Cloud (github.com)

Future Outlook

In future the idea is to provide such a generator as well in the ABAP development tools for Eclipse.

This will be possible with the next S/4HANA release and the ADT generator framework.