SAP Community - ABAP Cloud

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

Update 1: 16th May, 2024: File upload vulnerability - Workaround

Symptom

An unauthenticated attacker can upload a malicious file to the server which when accessed by a victim can allow the attacker to access, modify or make unavailable user's information and system.

Reason

The Content Repository "FILESYSTEM" and "SOMU_DB" are configured with "No Signature" checked.

Workaround

To ensure that a secure default configuration is implemented, correct your system as follows .

If you have the relevant access, you can refer to SAP Note 3448171 for more details.

Note that this workaround is a temporary fix and is not a permanent solution. SAP strongly recommends you apply the corrections outlined in the security note, which can be done in lieu of the workaround or after the workaround is implemented:

Execute Transaction 'OAC0'
Open the content repository 'FILESYSTEM' for all releases.
Change the Version Number to '0047' (Content Server Version 4.7)
Uncheck the checkbox "No Signature"
Save the settings.
Execute Transaction 'OAC0'
Open the content repository 'SOMU_DB' in case of release 7.50 or higher.
Change the Version Number to '0047' (Content Server Version 4.7)
Uncheck the checkbox "No Signature"
Save the settings.

Update 2: 16th May, 2024: version 1909 will be withdrawn!

On Thursday, 16th May, we will have to withdraw the ABAP Cloud Developer Trial, 1909 from Docker.

If you need this version for any reason, please make sure you have downloaded it in good time.

Otherwise, we recommend the version below:

Now Available:

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, start SLICENSE again, then choose Install.
Log off, then log on with the user DEVELOPER, client 001.
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.

Issue: Docker container works only for a few hours: "

Since I cannot currently edit the FAQ, I am repeating the following from Attila

"I disabled the Resource Saver in Docker Desktop, and it fixed the connection issue happening after few ours of my Win11 computer is idle / locked.

According to the Docker documentation the Resource Saver setting should not suspend tcp connections or similar. Do not understand why, but looks like it works."

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

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:

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.

Calling Fragment Form & Send it as an attachment using ABAP Walk-Through

2024-05-15T21:53:21.876000+02:00

This Blog is based on the Output Management Form and has all of its configuration completed

Ex for dunning: use maintenance view: V_T047E using code: sm30 to switch between frameworks through drop-down list

First: you can identify Fields for Key & Master Key internal tables for standard fragment form through putting a breaking point

By using framework: sap cloud and using fragment form template and of course maintain brf+ configuration

In class: CL_SOMU_FORM_SERVICES , Method : GET_DOCUMENT

Put a break point in the first line and go back to the previous program to see internal tables passed to form calling for keys.
Take screenshots for them, as you will be using them for the custom calling of the form as these fields are maintained according to configuration & master form template derivation.
If you need the application ID Key, it’s a concatenation between multiple variables, You will find it in the call back class specific to a given object in the SPRO configuration

SPRO -> CROSS APPLICATION COMPONENTS -> OUTPUT CONTROL (here you can find all of OM Configuration) -> DEFINE OUTPUT TYPE THEN SELECT THE ENTRY CORRESPONDING TO YOUR BRF+ ROLE and click details, you will find your call back class, in our class for dunning : CL_FIN_FO_DUNN_OUTPUT , all call back classes Implement same interface, then go into method : IF_APOC_COMMON_API~GET_FDP_PARAMETER

Second step:

Activate the legacy printout system and put a breakpoint inside the printing object whether it’s a program or function module, if you are using PDF, you can put a breakpoint in open job FM and trace back through the stack to the transaction screen printing program

In our case for dunning: It prints using FM : “PRINT_DUNNING_NOTICE_PDF”, put a breakpoint there

Start comparing the values of the key & master key internal table with local variables available to locate the objects that contain the data which will be passed to the fragment forms Key internal tables from the standard
1. You will find all the data u need in the objects because whether it is fragment, PDF or whatever technology, the system always collects the same data passed one way or the other
After that start creating your custom code to call the fragment form
- Consider the condition to identify which master form template to use.
Create an enhancement in the standard program to defuse the standard code and prevent its execution, make sure that the standard code doesn’t update standard somewhere along the code as you need to confirm whether it happens through the OData service of fragment or not! ( because if not you will have to use the standard code that does that to make everything consistent )

then test the cycle end to end

in our case , here is the example for the PO Form

I created a custom program se38 to test using po form

*&---------------------------------------------------------------------*
*& Report ZDUMMY
*&---------------------------------------------------------------------*
*&
*&---------------------------------------------------------------------*
REPORT ZDUMMY.




SELECTION-SCREEN BEGIN OF BLOCK b1.
  PARAMETERS: p_po_num TYPE ebeln MATCHCODE OBJECT h_ekko OBLIGATORY.
SELECTION-SCREEN END OF BLOCK b1.



INITIALIZATION.



START-OF-SELECTION.
  DATA: lo_cl_somu_form_services TYPE REF TO cl_somu_form_services.
  DATA: lt_keys TYPE cl_somu_form_services=>ty_gt_key.
  DATA: ls_ekko TYPE ekko.
  DATA: lt_master_keys TYPE cl_somu_form_services=>ty_gt_key.
  DATA: lv_content TYPE  xstring.
  DATA: lv_xml TYPE xstring.
  DATA: lv_pages TYPE  fppagecount.
  DATA: lv_trace_string  TYPE string.
  DATA: lv_stop_processing TYPE  abap_bool.
  DATA: lt_message TYPE cl_somu_form_services=>ty_gt_message.
  DATA: lv_output_length TYPE i.
  DATA: lt_generated_pdf  TYPE STANDARD TABLE OF tbl1024 .

  FIELD-SYMBOLS: <ls_key> TYPE cl_somu_form_services=>ty_gs_key.



  SELECT SINGLE *
    FROM ekko
    INTO ls_ekko
    WHERE ebeln = p_po_num.


  " --------------------------- Values for the purchase order form ---------------------------
  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'PurchaseOrder'.
  <ls_key>-value = p_po_num.

  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'SenderCountry'.
  <ls_key>-value = 'DE'.

  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'PurchaseOrderChangeFlag'.
  <ls_key>-value = space.

  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'Language'.
  <ls_key>-value = 'E'.


  APPEND INITIAL LINE TO lt_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'ReceiverPartnerNumber'.
  <ls_key>-value = ls_ekko-lifnr.

  " --------------------------- Values for the master form template ---------------------------
  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'PrintFormDerivationRule'.
  <ls_key>-value = 'PURCHASE_ORDER_MASTER_FOR_COMPANY'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'WatermarkText'.
  <ls_key>-value = space.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'LocaleCountry'.
  <ls_key>-value = 'DE'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'LocaleLanguage'.
  <ls_key>-value = 'E'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'OutputControlApplicationObjectType'.
  <ls_key>-value = 'PURCHASE_ORDER'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'OutputControlApplicationObject'.
  <ls_key>-value = p_po_num.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'OutputRequestItem'.
  <ls_key>-value = '000001'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'OutputDocumentType'.
  <ls_key>-value = 'PURCHASE_ORDER'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'Recipient'.
  <ls_key>-value = ls_ekko-lifnr.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'RecipientRole'.
  <ls_key>-value = 'LF'.

  APPEND INITIAL LINE TO lt_master_keys ASSIGNING <ls_key>.
  <ls_key>-name = 'SenderCountry'.
  <ls_key>-value = 'DE'.


  lo_cl_somu_form_services = cl_somu_form_services=>get_instance( ).


  lo_cl_somu_form_services->get_document( 
   EXPORTING iv_master_form_name  = 'SOMU_FORM_MASTER_A4'
             iv_form_name         = 'MM_PUR_PURCHASE_ORDER'
             it_key               = lt_keys
             it_master_key        = lt_master_keys
             iv_form_language     = 'E'
             iv_form_country      = 'DE'
  IMPORTING  ev_content          = lv_content
             ev_xml               = lv_xml
             ev_pages             = lv_pages
             ev_trace_string      = lv_trace_string
             ev_stop_processing   = lv_stop_processing
             et_message           = lt_message ).
  IF sy-subrc <> 0.
  ENDIF.


  CALL FUNCTION 'SCMS_XSTRING_TO_BINARY'
    EXPORTING
      buffer        = lv_content
    IMPORTING
      output_length = lv_output_length
    TABLES
      binary_tab    = lt_generated_pdf.


  " Shows a preview of the generated PDF file in a popup window.
  CALL FUNCTION 'FDM_COLL_INV_PDF_SHOW'
    EXPORTING
      t_pdf = lt_generated_pdf.


"=================================================================================================================

  "Object References
DATA: lo_bcs         TYPE REF TO cl_bcs,
      lo_doc_bcs     TYPE REF TO cl_document_bcs,
      lo_recep       TYPE REF TO if_recipient_bcs,
      lo_sapuser_bcs TYPE REF TO cl_sapuser_bcs,
      lo_cx_bcx      TYPE REF TO cx_bcs,
      lv_string_text  TYPE string,
      lt_text           TYPE bcsy_text,
      lv_bin_filesize TYPE so_obj_len,
      lv_sent_to_all  TYPE os_boolean,
      lt_binary_content TYPE solix_tab.

  CALL FUNCTION 'SCMS_XSTRING_TO_BINARY'
    EXPORTING
      buffer        = lv_content
    IMPORTING
      output_length = lv_output_length
    TABLES
      binary_tab    = lt_binary_content[].

lv_bin_filesize = lv_output_length.

  TRY.
*     -------- create persistent send request ------------------------
    lo_bcs = cl_bcs=>create_persistent( ).
      "First line
      CONCATENATE 
                 'Dear Colleague' cl_abap_char_utilities=>newline 
      INTO lv_string_text.
    APPEND lv_string_text TO lt_text.
    CLEAR lv_string_text.
    "Second line
    CONCATENATE 'Please find attached a test smartform.'
     cl_abap_char_utilities=>newline INTO lv_string_text.
    APPEND lv_string_text TO lt_text.
    CLEAR lv_string_text.
    "Third line
    APPEND 'Best Regards,' TO lt_text.
    "Fourth line
    APPEND 'Systems Administrator.' TO lt_text.

*---------------------------------------------------------------------
*-----------------&      Create Document     *------------------------
*---------------------------------------------------------------------
    lo_doc_bcs = cl_document_bcs=>create_document(
                    i_type    = 'RAW'
                    i_text    = lt_text[]
                    i_length  = '12'
                    i_subject = 'Test Email' ).   "Subject of the Email

*---------------------------------------------------------------------
*-----------------&   Add attachment to document     *----------------
*---------------------------------------------------------------------
*     BCS expects document content here e.g. from document upload
*     binary_content = ...
    CALL METHOD lo_doc_bcs->add_attachment
      EXPORTING
        i_attachment_type    = 'PDF'
        i_attachment_size    = lv_bin_filesize
        i_attachment_subject = 'Test Email'
        i_att_content_hex    = lt_binary_content.

*     add document to send request
    CALL METHOD lo_bcs->set_document( lo_doc_bcs ).

*---------------------------------------------------------------------
*------------------------&   Set Sender     *-------------------------
*---------------------------------------------------------------------
*    lo_sapuser_bcs = cl_sapuser_bcs=>create( sy-uname ).
*    CALL METHOD lo_bcs->set_sender
*      EXPORTING
*        i_sender = lo_sapuser_bcs.

lo_recep = 
cl_cam_address_bcs=>create_internet_address('Receiving Email Address').

"Add recipient with its respective attributes to send request
    CALL METHOD lo_bcs->add_recipient
      EXPORTING
        i_recipient = lo_recep
        i_express   = 'X'.

    CALL METHOD lo_bcs->set_send_immediately
      EXPORTING
        i_send_immediately = 'X'.

*---------------------------------------------------------------------
*-----------------&   Send the email    *-----------------------------
*---------------------------------------------------------------------
    CALL METHOD lo_bcs->send(
      EXPORTING
        i_with_error_screen = 'X'
      RECEIVING
        result              = lv_sent_to_all ).

    IF lv_sent_to_all IS NOT INITIAL.
      COMMIT WORK.
    ENDIF.


*---------------------------------------------------------------------
*-----------------&   Exception Handling     *------------------------
*---------------------------------------------------------------------
  CATCH cx_bcs INTO lo_cx_bcx.
    "Appropriate Exception Handling
    WRITE: 'Exception:', lo_cx_bcx->error_type.
ENDTRY.

PS. you can use same concept if you are creating a total custom fragment on your own but you need to

Create OData Model
Create Master Template using Maintain Form Template Fiori APP / SFP

Create Content Template using Maintain Form Template Fiori APP / SFP

Start building Up your Solution, i haven't tried build a full custom solution from A to Z but this is the main idea for it

SAP BTP ABAP Environment – Release 2405

2024-05-17T21:33:18.532000+02:00

As follow-up to our previous release 2402, this blog post provides an update to our most recent release 2405, which is available for customers and partners on May 18th/ 19th. Please enjoy my little overview of the most important features.

Many thanks to Florian Wahl for his contributions to this blog post!

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

ABAP Development Tools

Enhancements to authorization check issue handling relating to authorization object S_DEVELOP (details)
Availability of new editors for launchpad spaces and page template (details)
Support for clear console when running an ABAP application (details)
Support for exporting an ABAP runtime error as ZIP file (details)
Support for display application job catalog entries (details)
Support for ATC checks for knowledge transfer documents (details)
Availability of new property ABAP language version (details)
Support for display of failed assertions and status test methods (details)
Enhancements to large ABAP traces for better handling (details)
Support for ABAP contract check violations feed (details)
Support for custom code migration project scheduling via application jobs (details)
Support for software component relations editor (details)
Support for toggling the step size in the ABAP debugger (details)
Support for launching ABAP unit tests with quick actions (details)
Support for test code highlighting for method calls (details)
Support for quick action usage to insert ABAP unit test class templates (details)
Support for template context while creating metadata extensions (details)
Support for tool bridges between ABAP Development Tools for Eclipse and VS Code/BAS (details)
Support for display remote ATC runs from SAP BTP (details)

ABAP RESTful Application Programming Model

Support for subentities as authorization master that are not defined as root entity
Support for entity assignment of RAP business events
Support for defining result cardinality [1..*] for factory actions

Administration

IP address changes on AWS (details)
Support for display whether dependent business catalog is optional (details)
Support for defining several general restrictions by leading and filter undefined restrictions in Maintain Restrictions UI (details)
Support for factory calendar pull integration from SAP S/4HANA Cloud to SAP BTP, ABAP environment (details)
Support for table analysis of table statistics from aggregated views over time (details)
Support for merging spaces and pages at the same time (details, details)
Support for translation of new CDS annotation: UI.dataPoint.title, EnterpriseSearch.modelName and EnterpriseSearch.modelNamePlural (details)
Support for upload of primary and secondary signing certificate (details)

Integration & Connectivity

Support for setting the AIR key as custom HTTP header field to a SOAP request (details)

Key User Extensibility

Support for user names in Manage View dialog (details)

Reuse Services

Support for usage of source templates to provide content specification of a metadata extension and reading the longtext of a message using the XCO library (details)

Data Access

Support for SQL-based remote access from SAP HANA Cloud databases to ABAP system (details)

Additional Information

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

For the new documentation structure, see Standalone Documentation. The new documentation page makes search and navigation for SAP BTP, ABAP environment topics easier.

In addition to the Roadmap Explorer, see SAP BTP, ABAP environment Roadmap for more details on the roadmap items.

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

Stay healthy and take care!

Customer & Partner Roundtable for SAP BTP ABAP Environment #13

2024-05-27T19:39:26.752000+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:

June 25th, 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), Katharina Wurz (Developer ABAP Development Tools), Thomas Fiedler (Area Product Owner ABAP Developer Tools), Florian Wahl, Iwona Hahn & Burcu Karlidag (BTP ABAP Product Managers)

Preliminary Agenda:

Product news
Baseline Support for ABAP Test Cockpit in SAP BTP incl. demo
Roadmap for AI in ABAP Cloud
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.

My Code Connect 2024 Experience

2024-06-11T02:15:40.162000+02:00

Here I am, on a plane flying back from Code Connect at the SAP headquarters in Germany. I'm still processing everything, mentally replaying some of the sessions I had attended, eager to watch the ones I couldn't. Stuck on a plane isn't fun, so I decided to write about my experience at the event. I won't talk about the content presented because anybody can watch it online once available. I want to talk a little bit about how it felt being there.

If you don't know what Code Connect is, here's a brief intro. It's the merge of 3 different conferences (reCAP + UI5con + ABAPconf) with a whole day dedicated to a single technology. It was dabbed as the "new TechEd" by the attendees. I've heard it sooooo many times!

Short comments on the days and a brain dump on everything in between...

Day 0, CodeJam, started with a hands-on workshop on CAP conducted by the legend DJ Adams. Man, he's a walking geek encyclopedia and master of the random geek fun facts.

SAP CodeJam

Day 1, reCAP, was all about how CAP is so f* powerful and simple at the same time (sorry, I couldn't find any better word). In my humble opinion, it cemented the idea of CAP becoming the framework people will use to build most of the custom things SAP-related.

Welcome to reCAP 2024

Day 2, UI5con, showed that UI5 can do much more than Fiori Elements apps. It's modern, solid and can render fast!

Full house to watch Peter Muessig

Day 3, ABAPconf, I can summarize with: ABAP is not dead! It's not going anywhere. Actually, it's going to the cloud. So many new tools and techniques to make RAP better and easier to work with.

ABAP Clean Core

For 4 days I soaked up knowledge shared on the stages, and most importantly, the invaluable experiences and real-life challenges shared in conversations throughout the day.

I met old friends, I made new friends, I met people that I’ve known for ages, but have never seen in person. Some were not as tall as I was expecting (sorry man 😜). I saw great ideas, I saw captivating speakers, and I saw smart code, which makes me even more nervous when presenting because they're far ahead of my limited capabilities.

The common feeling is that we were part of a large community, full of people from all backgrounds and skill levels, but with one thing in common: the love for SAP technology. We all belonged there. It was the Woodstock of SAP! Without the LSD, but full of talented people, good music and LOTS of fun! A unique moment that may spark a renaissance of the SAP community itself because I do believe people will contact each other to collaborate on new projects.

Code Connect was a beast packed with actionable insights and lessons from the sessions. Each day was focused on one technology only. There was no "this feature will be available next Christmas". Everything shared in those 3 days was possible to play with straight away. For instance, after my session, people told me they would test that out once they got to their homes. On the following day, somebody said they had implemented some of the suggestions. Bloody hell!!!

The same happened to others. All sessions shared this one little thing: no vaporware, just real code. Even the sessions touching genAI, the biggest buzzword ever, showed real applications that anybody could test today.

You could see people chatting around, sharing what they are doing, the projects they are working on. Some of the things that I heard: what they like in CAP (easy to learn, higher productivity), how they are adopting ABAP Cloud (more on BTP than the embedded one), hackathons are still the best way to learn new tech in house. These conversations would get even better in the evening as we sat outdoors listening to good music, playing some games and having some drinks. Every night I'd leave the premises around 10pm and people were still there... If they kept the place open and the music playing in a 24h old LAN party style, people wouldn't leave.

Whoever had the idea to combine forces and bundle these 3 conferences in a blockbuster event deserves all the accolades from the SAP community at large. The people behind the event are definitely onto something special. Keep up the awesome work!!! And please, please, please... Keep SAP marketing and sales at bay. They already have their events, let us have ours. As the ABAPconf sign stated: “by developers for developers”.

I just want to say thank you to the organisation, and to everyone behind this magnificent event. Thank you to all the speakers who invested time in preparing the sessions, for sharing your knowledge and experience. Thank you to all the attendees because without you the event would be nothing. And thank you to the sponsors for funding such a large, complex and beautiful idea.

It might be unfair to the others, but I must mention some people, not from the organisation, but from the community...

Svea and her team for being there listening to the community. They could hide themselves in a room and avoid the negative feedback for the infamous new platform they knew they'd get, but they didn't. It requires courage and I respect it. We all hope to see the changes being implemented sooner rather than later.

The crew from Portugal which I believe was the biggest group representing a customer there! They even had their own CAPs 🧢

Portugal represented

The Ned Kelly Gang from Down Under! +20 hours on a plane to attend an event because they want to, not because they were told to speaks volumes. You (we?) guys rock!

The Ned Kelly Gang missing some members

PS: hear me out now... Add an extra day for SAP BTP in the Code Connect (BTPconf?) and we definitely have something better than TechEd 😜

3 developers

About to start my session and have some fun

LEGO Fender I won in a raffle, thanks dox42 \o/

ABAP Cloud Developer Trial 2022: My Experience

2024-06-11T19:40:00.027000+02:00

As many of you may have heard, the ABAP Cloud Developer Trial 2022 is now available on Docker. Consequently, the ABAP Cloud Developer Trial 1909 from Docker will be withdrawn. Check out Julie Plummer's blog post for all the details about what’s included, highlights of the release, and additional reading about ABAP Cloud and extensibility: ABAP Cloud Developer Trial 2022 Available Now | Blog Post

In this blog post, I want to share my personal experiences installing the new ABAP developer edition on my MacBook with an Intel processor, especially since the older version is set to disappear from Docker. On the newest MacOS version, you can no longer run ABAP Cloud Developer Trial on Docker Desktop for MacBooks with an M-series processor. Thankfully, my MacBook with its Intel processor meant I dodged the compatibility issues—no need for workarounds or additional setups. If you are working with an M-series processor, I recommend checking out this blog post from our community member @dylan-drummond, who has written an exhaustive guide.

The ABAP Cloud Developer Trial is a free, downloadable ABAP Platform on SAP HANA 2.0 for trying out the ABAP language and toolset. It comes pre-configured with SAP Fiori launchpad, SAP Cloud Connector, backend/frontend connections, roles, and sample applications. This is the new name for ABAP Platform Trial, highlighting that you can now develop in the new ABAP Language Version, ABAP for Cloud Development.

Docker Desktop for MacBook

Understanding Docker container technology fundamentals is crucial, as the trial runs on a Docker platform. I suggest starting with the Setup Instructions available on the Docker Hub page: ABAP Cloud Developer Trial 2022. This contains a lot of useful information needed to set up the container. This will save you time and help avoid the mistake I made by skimming through briefly.

When you open Docker Desktop for the first time, you need to accept the Docker Subscription Service Agreement. If you are using Docker Desktop for work purposes, you need to discuss with your employer whether you need a paid subscription.

In the settings screen, I recommend adjusting the resources settings. Make sure you have assigned enough disk space to your Docker setup. The image is around 50GB when compressed. It would be frustrating to spend time downloading the image only to find out Docker does not have enough disk space to unpack it.

- CPU limit: 6

- Memory limit: 28 GB (you might get away with less)

- Swap limit: 2 GB

- Virtual disk limit: 248 GB

You can probably get by with a slightly smaller disk size, but the image takes up over 50GB on disk.

Installation Tips

One major tip during installation is to read the entire section of the documentation first. Don’t just cut and paste the command from the documentation without understanding them.

There are two ways to do this: using the command line (Docker Engine, which you installed as part of Docker Desktop setup) or using the GUI app (Docker Desktop, which in the background uses Docker Engine). The GUI app method is to search in the top bar of Docker Desktop for the image, then press Pull. The command line method is:

sudo docker pull sapse/abap-cloud-developer-trial

The pull operation will take some time because there is over 20 GB of data to download, extract, and write to the local image repo of the Docker. Be patient. If the process fails, start it again (either from the GUI app or command line). Eventually, the image will be viewable in Docker Desktop’s Images tab and via the command.

Next, start up the a4h container. I’ll suggest doing this from the command line to specify all the options we want and immediately follow the command’s progress. Ensure Docker Desktop is running. The command is:

sudo docker run --stop-timeout 3600 -it --name a4h -h vhcala4hci -p 3200:3200 -p 3300:3300 -p 3601:3601 -p 8443:8443 -p 30213:30213 -p 50000:50000 -p 50001:50001 sapse/abap-cloud-developer-trial:ABAPTRIAL_2022 -skip-limits-check -agree-to-sap-license

Anyone running on Mac or Windows needs to add the "-skip-limits-check" to the run command. You also probably want to add the "agree-to-sap-license" switch to the run command to avoid having to start the container in interactive mode to accept the agreement.You can follow the Terminal window output and the progress in Docker Desktop.

You will now be able to set up the SAP GUI connection. The ABAP Cloud Developer Trial 2022 has a new password: ABAPtr2022#00. The username is DEVELOPER and the client is either 001 for development or 000 for admin tasks.

The system should be up and running, and you can see it is also visible in Eclipse

Wrapping Up

Overall, installing and using the ABAP Cloud Developer Trial 2022 on Docker was quite easy. The new version is packed with features and pre-configured tools, making it easy to dive into ABAP development. Intel MacBook users will find the process straightforward, while those with M-series processors might need some extra steps for compatibility.

All that I've detailed here is additional background and exploration information for those who want to learn more. The most important thing is just to get started!

For a deeper dive into the specifics, including the features and release highlights, check out Julie Plummer’s blog post. This post also provides links to further information on ABAP Cloud and its extensibility.

If you need advice on any of the steps I mentioned, like logging into the SAP System or getting an A4H license, refer to the official advice from SAP on the ABAP Cloud Developer trial site

Upload and modify OpenXML documents via RAP App in SAP BTP ABAP Environment

2024-06-12T21:50:36.096000+02:00

Introduction

In this blog post, I would like to share some insights for generating OpenXML documents by use of the RESTful Application Programming Model with Cloud-released development objects. With this app, you will be able to upload .docx templates and fill them with information from you CDS view (could be used for generating invoices, business documents and so on...).

Prerequesites

SAP BTP ABAP environment or an S/4 system to your disposal.
Eclipse IDE installed on your local machine with the ABAP Development Tools.

Shortcut with abapGit:

For those who are using abapGit, feel free to check out the code from my GitHub repo!

Step 1:

Create a database table with the following config (hint: do not forget to generate custom domains for mime type and attachment type, information on how to do this can be found here.

@EndUserText.label : 'Invoice for document generation'
@AbapCatalog.enhancement.category : #EXTENSIBLE_ANY
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table zmri_invoice {

  key client            : abap.clnt not null;
  key invoice           : ebeln not null;
  comments              : abap.char(30);
  attachment            : zmriattachment;
  mimetype              : zmimetype;
  filename              : zfilename;
  purchaseorder         : abap.char(30);
  price                 : abap.dec(8,2);
  local_created_by      : abp_creation_user;
  local_created_at      : abp_creation_tstmpl;
  local_last_changed_by : abp_locinst_lastchange_user;
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
  last_changed_at       : abp_lastchange_tstmpl;

}

Step 2:

Generate ABAP repository objects by right-clicking on the previously created database table.
Choose the ABAP RESTful Application Programming Model (OData UI Service) variant.

Step 3

Create a custom action in your Behavior Definition:

managed implementation in class ZBP_R_MRI_INVOICE unique;
strict ( 2 );
with draft;
define behavior for ZR_MRI_INVOICE alias ZrMriInvoice
persistent table ZMRI_INVOICE
draft table ZMRI_INVOIC000_D
etag master LocalLastChangedAt
lock master total etag LastChangedAt
authorization master( global )

{
  field ( mandatory : create )
   Invoice;

  field ( readonly )
   LocalCreatedBy,
   LocalCreatedAt,
   LocalLastChangedBy,
   LocalLastChangedAt,
   LastChangedAt;

  field ( readonly : update )
   Invoice;


  create;
  update;
  delete;

  action ( features : global ) createMSWordInvoice ;

  draft action Activate optimized;
  draft action Discard;
  draft action Edit;
  draft action Resume;
  draft determine action Prepare;



  mapping for ZMRI_INVOICE
  {
    Invoice = invoice;
    Comments = comments;
    Attachment = attachment;
    Mimetype = mimetype;
    Filename = filename;
    PurchaseOrder = purchaseOrder;
    Price = price;
    LocalCreatedBy = local_created_by;
    LocalCreatedAt = local_created_at;
    LocalLastChangedBy = local_last_changed_by;
    LocalLastChangedAt = local_last_changed_at;
    LastChangedAt = last_changed_at;
  }
}

Step 4:

Implement the custom action in your behaviour implementation class:

CLASS lhc_zr_mri_invoice DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.

    CLASS-DATA: mt_data TYPE zmri_invoice.

    DATA:
          lv_content   TYPE xstring,
          lo_zip       TYPE REF TO cl_abap_zip.

    METHODS:
      get_global_authorizations FOR GLOBAL AUTHORIZATION
        IMPORTING
        REQUEST requested_authorizations FOR ZrMriInvoice
        RESULT result,

      get_global_features FOR GLOBAL FEATURES
        IMPORTING
        REQUEST requested_features FOR ZrMriInvoice
        RESULT result,

      createMSWordInvoice FOR MODIFY
        IMPORTING keys FOR ACTION ZrMriInvoice~createMSWordInvoice.

ENDCLASS.

CLASS lhc_zr_mri_invoice IMPLEMENTATION.

  METHOD get_global_authorizations.
*  This method does not need an implementation
  ENDMETHOD.

  METHOD createMSWordInvoice.

*     Select document to be filled
    SELECT * FROM zc_mri_invoice
     FOR ALL ENTRIES IN @keys
     WHERE invoice      = @keys-invoice
     INTO CORRESPONDING FIELDS OF @MT_data.
    ENDSELECT.

*     Create zip class instance
    lo_zip = NEW cl_abap_zip( ).

*     Search for main document part
    DATA lv_index TYPE string VALUE 'word/document.xml'.

*     Load attachment into zip class object
    lo_zip->load( zip = mt_data-attachment check_header = abap_false ).

*     Fetch the binaries of the XML part in the attachment
    lo_zip->get(
    EXPORTING
      name   = lv_index
    IMPORTING
      content = lv_content
    ).


* Convert the binaries of the xml into a string
    DATA(lv_string) = xco_cp=>xstring( lv_content
      )->as_string( xco_cp_character=>code_page->utf_8
      )->value.

* Search for the text to be replaced and fill with the information in your data set
    REPLACE FIRST OCCURRENCE OF '&lt;InvoiceNumber&gt;' IN lv_string
    WITH mt_data-Invoice.

    REPLACE FIRST OCCURRENCE OF '&lt;Purchase Order&gt;' IN lv_string
    WITH mt_data-PurchaseOrder.

    REPLACE FIRST OCCURRENCE OF '&lt;Comments&gt;' IN lv_string
    WITH mt_data-Comments.

    DATA lv_price TYPE string.
    lv_price = mt_data-Price.

    REPLACE FIRST OCCURRENCE OF '&lt;Price&gt;' IN lv_string
    WITH lv_price.

* Convert the changed XML string into binaries
    DATA(lv_new_content) = xco_cp=>string( lv_string )->as_xstring( xco_cp_character=>code_page->utf_8
    )->value.

* Delete "old" main document part from the zip file
    lo_zip->delete(
    EXPORTING
      name   = lv_index
    ).

* Add "new" main document part to the zip file
    lo_zip->add(
    EXPORTING
      name   = lv_index
      content = lv_new_content
    ).

* Save the new zip file
    DATA(lv_new_file) = lo_zip->save( ).

* Upload changed docx file
    MODIFY ENTITIES OF zr_mri_invoice IN LOCAL MODE ENTITY ZrMriInvoice
      UPDATE SET FIELDS WITH
      VALUE #( (
          Invoice = mt_data-Invoice
          Attachment = lv_new_file
      )  )
    FAILED failed.

    APPEND VALUE #( %msg = new_message_with_text( severity = if_abap_behv_message=>severity-success text = 'Template successfully filled...' ) ) TO reported-ZrMriInvoice.
  ENDMETHOD.

  METHOD get_global_features.
* This method does not need to be implemented
  ENDMETHOD.


ENDCLASS.

Explanation: In this implementation class, the cl_abap_zip class (which is released for cloud development) is used to load the .docx template. If you didn't already know, a .docx file is basically a ZIP-file. In order to get the main document part, we need to fetch the "word/document.xml" file within the zip object by applying the lo_zip->get() method. This method returns an XSTRING which has to be converted into an UTF-8 encoded string, for us to modify the content of the main document part. For the binary-to-string conversions the xco_cp class is used, which is part of the XCO library (I can only recommend using this library as it has some great features). Afterwards the converted XML-string has to be modified with the invoice details from your CDS view. The modified XML-string has to be converted back into binaries, by use of the same class. The last step is to delete the "old" main document part from the zip object and add the new document content to the zip object. Now update the attachment field in your CDS entity and that's it. Your app should now be able to populate a .docx-file with information from your CDS view.

Step 5:

Create a metadata extension and a service binding for your Fiori Frontend and test the application:

@Metadata.layer: #CORE
@UI: { headerInfo: {
typeName: 'Invoice',
typeNamePlural: 'Invoices',
title: { type: #STANDARD, value: 'Invoice' },
         description: { type: #STANDARD, value: 'Invoice' } },
         presentationVariant: [{
         sortOrder: [{ by: 'Invoice', direction: #ASC }],
         visualizations: [{type: #AS_LINEITEM}] }] }
annotate view ZC_MRI_INVOICE with
{
  .facet: [    {
                label: 'General Information',
                id: 'GeneralInfo',
                type: #COLLECTION,
                position: 10
                },
                     { id:            'Invoicedet',
                    purpose:       #STANDARD,
                    type:          #IDENTIFICATION_REFERENCE,
                    label:         'Invoice Details',
                    parentId: 'GeneralInfo',
                    position:      10 } ]

  : { lineItem:       [ { position: 10, importance: #HIGH , label: 'Invoice Number'} ] ,
          identification: [ { position: 10 , label: 'Invoice Number' } ] }
  Invoice;
  : { lineItem:       [ { position: 20, importance: #HIGH , label: 'Purchase Order'} ] ,
           identification: [ { position: 20 , label: 'Purchase Order Number' } ] }
  PurchaseOrder;
  : { lineItem:       [ { position: 20, importance: #HIGH , label: 'Price'} ] ,
           identification: [ { position: 20 , label: 'Price' } ] }
  Price;
  : { lineItem:       [ { position: 20, importance: #HIGH , label: 'Comments'} ] ,
           identification: [ { position: 20 , label: 'Comments' } ] }
  Comments;
  :
  { lineItem:       [ { position: 30, importance: #HIGH , label: 'Attachment'}, { type: #FOR_ACTION, dataAction: 'createMSWordInvoice' , label: 'Create Invoice' } ], 
    identification: [ { position: 20 , label: 'Attachment' }] 
  }
  Attachment;

  .hidden: true
  MimeType;

  .hidden: true
  Filename;


}

Test the application by creating an entry and uploading a docx-template.

The template could look something like this:

Now select the entry and use the custom action to fill the template with your data:

After the success message, click on the attachment (template.docx) and verify that the placeholders have been filled:

Addition:

For those of you who want to populate tables in MS word, you can have a look at this blog post, which uses text and row fragments for placeholders in the docx-template.

Conclusion:

In this blog post, you learned how to upload and modify OpenXML documents by use of the cl_abap_zip class and the XCO library. This code is consists of cloud-released code only and should give you a good starting point to start handling your documents with a clean core approach.

Replacing a wrapped BAPI with a released business object interface

2024-06-13T15:11:13.346000+02:00

Last year, I announced the release of the Mitigate Missing Released SAP API in the 3-tier Extensibility Model tutorial group via the ABAP Cloud – Mitigate missing released SAP APIs in the 3-tier extensibility model: a tutorial how to wrap a BAPI and integrate it into a custom RAP business object blog. The tutorial group shows how to wrap the BAPI_PR_CREATE function module (BAPI) in tier 2, how to release it for consumption in tier 1, and then how to consume it from a shopping cart RAP business object in tier 1.

We have just extended the tutorial group with the Replace Wrapper by Released API tutorial. As the name suggests, this tutorial shows how to replace the wrapper once a released API is available. That is, the wrapper for the BAPI_PR_CREATE function module is replaced by the released I_PurchaseRequisitionTP business object interface. Since the business object interface is already available, you can try it out immediately. So, don't hesitate and get your hands dirty 😉

SAP Developer News, June 20th, 2024

2024-06-20T21:10:00.081000+02:00

DESCRIPTION

Generate your own custom UI Service based on a Business Object Interface

Tutorial to generate Custom UI Service based on a C1-released Business Object Interface: https://developers.sap.com/tutorials/abap-cloud-ui-from-interface.html

SAP Open Source Webinar “How to fight the dependency hell”

Renovate https://github.com/renovatebot/renovate
Webinar details & registration: https://events.sap.com/how-to-fight-dependency-hell/en/registration.aspx
OSPO Webinars home page https://events.sap.com/ospo-webinars/en/home

Collaborate on your SAP Build Code project with your teammates!

Tutorial to set up Build Code on BTP: https://developers.sap.com/tutorials/build-code-setup..html
Help Portal - Managing Members : https://help.sap.com/docs/SAP%20Build/9d385a1842594230993661ca78dce150/1ae0d5af7a9946cc96936bd175041148.html
Blog post on Collaborate on your Build Code project by Rupa Maity: https://community.sap.com/t5/technology-blogs-by-sap/collaborate-on-your-sap-build-code-project-with-your-teammates/ba-p/13720813

API anomaly detection and Event Mesh capability of SAP Integration Suite

API Anomaly Detection in SAP Integration Suite: https://community.sap.com/t5/technology-blogs-by-sap/api-anomaly-detection-in-sap-integration-suite/ba-p/13726636
API Anomaly Detection infographic: https://community.sap.com/t5/technology-blogs-by-sap/use-the-api-anomaly-detection-feature-in-sap-integration-suite-to-detect/ba-p/13733045
Meet your new friend EMIS: Event Mesh in SAP Integration Suite: https://community.sap.com/t5/technology-blogs-by-sap/meet-your-new-friend-emis-event-mesh-in-sap-integration-suite/ba-p/13731129
Event-driven integrations: Exploring the Event Mesh capability of SAP Integration Suite: https://youtube.com/live/tUIG34xT3oo

CHAPTER TITLES

0:00 Intro
0:10 Generate your own custom UI Service based on a Business Object Interface
1:30 SAP Open Source Webinar “How to fight the dependency hell”
2:50 Collaborate on your SAP Build Code project with your teammates!
4:13 API anomaly detection and Event Mesh capability of SAP Integration Suite

TRANSCRIPT

This is the SAP Developer News for June 20th, 2024.

[Shilpa] Hello, ABAP developers. We all know business objects are the building blocks for modeling data. Well, business object interfaces are provided by SAP in order to release business objects so that it can be used or extended by customers using the ABAP Cloud development model. Now, by defining the stability contracts, it is possible to use such C1-released business object within other software components. Now, once you have used these business objects, you might want to create your own custom UI. In order to make it easier for customers to build custom UIs on top of the released business objects, SAP has provided a new wizard as part of the ABAP Development Tools in the latest series of SAP BTP, ABAP environment. Now, in this tutorial, our friend Andre Fischer shows how you can use this wizard to generate your own custom UI on top of the SAP C1 released business object interface, a ILSK bank TP. In this way, you can leverage growing number of released business objects that are based on ABAP RESTful application programming model to create your own UI on top as extension in ABAP Cloud. The link to this tutorial is in the description below. And we'll check it out.

[DJ] Making sure you're running the correct versions of software with the latest book fixes and features is a pretty important task. Scale this up to an enterprise the size of SAP, a producer and consumer of many, many open source libraries and packages, and this becomes a mammoth undertaking with those libraries, packages, and dependencies that are involved. There are many teams internally at SAP who have turned to the open source tool, Renovate, and use it at scale for this dependency management work. If this sounds interesting to you and you want to find out more, then we've got an upcoming SAP open-source webinar just for you. On the 25th of June, join Tobias Gabriel, a senior developer in the open source program office who will explain how SAP uses Renovate at scale, and also will talk about the shift, the paradigm shift towards the automation of dependency management in enterprises like SAP. All the details about this webinar and how to register are in the description.

[Shrini] Hello, SAP community. Would it be fun to share your code with your teammates? That's exactly what you can do with a build code project from the SAP Build Lobby. If you're interested in learning how to enable SAP Build Code in your BTP account, check out this tutorial. When you create a new full-stack project from the Build Lobby, you'll provide a project name, description, and select a dev space. If a dev space doesn't already exist, a new one will be created for you. Once your project is open, you can add any Git-based repository as a remote repo using the simplified Git panel. To share the project with your team members, we'll also need to add them as collaborators in the GitHub settings. In the SAP Build Lobby, you will find an option called Manage Members for your build code project. This feature allows you to authorize your team members to access the project as long as they have access to the same sub-account. Your team members can then access the project by selecting a dev space and providing their credentials. The repository will be cloned onto their dev space. If you need more guidance, Rupa has written a fantastic blog with step-by-step instructions. You can find the link in the description below.

[Antonio] Hola, SAP Developer. As part of the announcements that we had for SAP Sapphire, it was announced that there will be a new functionality in API management called the API anomaly detection. Now my colleague Shruthi recently published a blog post which shows you how to enable the functionality and lso what should you expect from this new functionality. There is also a very nice infographic that my colleague Kasturi created, which really distills what the functionality is. So make sure to check that out as well. There is now a new capability in SAP Integration Suite, which is the Event Mesh capability. So now Event Mesh is within the different capabilities that are part of SAP Integration Suite. Check out the blog post by Karsten, where he basically shares with us what you should expect from this new capability. And if you want to see the capability in action, this week I had the opportunity to do a livestream, where I basically go through the entire process of activating the new capability. Also, I connected to a CAP application, consume messages from Cloud Integration. We also connected to an S/4HANA Cloud. So make sure to check that out so that you can see the capability in action.

Customer & Partner Roundtable for SAP BTP ABAP Environment #14

2024-06-25T11:16:39.932000+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:

July 30th, 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), Daniela Fenderl, Chris Swanepoel, Iwona Hahn & Burcu Karlidag

Preliminary Agenda:

Product news and outlook
Hello, ABAP Cloud! Landing Page
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.

ABAP RESTful Application Programming Model (RAP)

2024-06-28T16:07:38.695000+02:00

Introduction

The SAP landscape has evolved significantly, with businesses seeking simpler, more efficient solutions that offer excellent user experiences. Many organizations remain deeply embedded in the SAP ecosystem, primarily focusing on ABAP over other languages. So, is it possible to develop feature-rich applications without other frontend languages? Yes, leveraging ABAP with RAP (ABAP Restful Application Programming) makes it possible.

Restful Application Programming is an ABAP programming model for creating business applications and services in an AS ABAP or BTP ABAP environment. RAP offers a standardized way of developing applications using Core Data Services (CDS), the modernized extended ABAP language, OData protocol, and the concept of business objects and services. RAP applications can only be created through ABAP development tools (ADT) and it’s available in SAP BTP ABAP Environment, SAP S/4 HANA Cloud, and AS ABAP >=7.56.

Before digging deeper into RAP, let’s explore CDS, annotations, and business services. To illustrate these concepts, let’s create a simple read-only list report application.

Developing an OData Service for simple list reporting

An OData service follows the best practices for developing and consuming RESTful APIs. This service can be used in SAP Fiori applications and can also be exposed as Web APIs. Below are the steps for creating a simple list report application:

Let’s explore each step in detail by creating the application.

Sample requirement: Create a read-only list report application which shows purchase order information.

Create an interface CDS view which takes data from Purchase Order Header (EKKO) and Item (EKPO).

Create two interface CDS views for showing master data of purchase order type and material details.

Make an association between the purchase order type CDS view and material details CDS view from the purchase order header/item CDS view. The associated views will act as Search Help in the list report after applying the annotations.
- Create a consumption view on top of the Purchase Order Header/Item interface view (ZI_PURCHASE_ORDER_RVN).
The UI annotations needed for the application are written in the consumption CDS View or Metadata Extensions.

Now, we have the data model and the required annotations to manifest semantics for it. The next step is to create the OData service and binding the service.
To define a service, we first need to create a service definition. In service definition, we specify the CDS entities that need to be exposed. In this example, the gateway client is replaced by the service definition and service binding.

As a last step, create the service binding for service definition.

Set the binding type as OData V2 – UI, since this is an OData V2 service.

After publishing the service, the exposed entity and associated entities will be visible. Click on the entity and click the preview button to see the preview of the application.

Purchasing Doc Type Search Help

Material Search Help

Conclusion

This blog serves as an introduction to developing OData services for simple list reporting using the ABAP Restful Application Programming (RAP) model. By following the steps outlined, you can create a read-only list report application that showcases purchase order information. We have covered the basics of creating CDS views, defining and binding OData services, and incorporating annotations for enhanced functionality.

This is just the beginning of what you can achieve with RAP. As you explore further, you will discover more advanced features and capabilities that can help you build robust, scalable, and user-friendly applications within the SAP ecosystem.

Happy Learning and exploring the vast possibilities with RAP!

References

https://help.sap.com/docs/abap-cloud/abap-rap/abap-restful-application-programming-model

https://help.sap.com/docs/abap-cloud/abap-rap/cds-annotations

CDS : How to define Hierarchy View

2024-07-17T14:18:20.286000+02:00

This blog is about how to define Hierarchy View in CDS.

There are two types of hierarchies – 'Leveled Hierarchy' and 'Parent-Child Hierarchy' In Analytics, only a Parent-Child hierarchy is supported.

In CDS, Hierarchy can be defined in two ways:

Inline Hierarchy: where the hierarchy definition is modelled in the dimension view.

External Hierarchy: where there is a separate CDS view to model the definition of the hierarchy.

In the past, External hierarchy was defined using the annotation '@ObjectModel.dataCategory: #HIERARCHY'. Now, in CDS it is allowed to define new type of CDS view called as Hierarchy CDS, which is defined using syntax define hierarchy, which create a hierarchical view.

A CDS hierarchy represents a HANA hierarchy, created when the CDS hierarchy is activated.

Normally the hierarchy contains headers and nodes. The header data of the hierarchy is coming from the directory view and the nodes data is coming from the hierarchy view itself.

Hierarchy Directory

The directory of the hierarchy provides the header information of the hierarchy. A hierarchy view might contain more than one hierarchy. Information about each hierarchy (e.g. text) is provided by a hierarchy directory. More information can be found in blog.

Typically, the directory view is defined as follows:

@EndUserText.label: 'Connection Hierarchy Directory View'
@Analytics : { dataCategory: #DIMENSION, dataExtraction.enabled: true }
@ObjectModel.representativeKey: 'hieid'

define view entity ZLR_CONNECTION_HIERARCHY_DIR
  as select from zoq_connid_hd
{
      @ObjectModel.text.element: [ 'hiertxt' ]
  key hieid,
      @Semantics.text: true
      hiertxt,
      @Semantics.systemDate.lastChangedAt: true
      last_changed,

}

Output

Hierarchy View using define hierarchy <NAME>

This is the new way of defining hierarchy and it is available from 2023 on Prem and 2308 Cloud. For defining hierarchy, prerequisite is having a source view, which is mentioned in the definition as parent child hierarchy source.

Source View

In view definition parent child association is define along with that following associations:

Association to hierarchy view itself- It defines parent child relationship
Association to hierarchy directory - It contains all the header information- hierarchy ids.
Association to different dimension/text views – It is a relation from the nodes and leaves to dimension and text views. Via this association the text of a node/leaf is derived. In the following example '_node' is first level node. '_airline' acts as second level node and '_connection' is leaf and pointing to dimension.
Extra conditions like 'carrid = "" ' are not necessary and the order of the associations is not relevant. Instead in this case a separate field is needed, which returns the fieldname of the records, which should be used. In the example it is field 'nodetype'

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Base for : New Way of defining Hierarchy'

define view entity ZLR_CONN_HIERARCHY_BASE
  as select from zoq_connid_h


  //association to itself.
  association [0..1] to ZLR_CONN_HIERARCHY_BASE      as _parent     on  $projection.hieid    = _parent.hieid
                                                                    and $projection.parentid = _parent.nodeid

  // association with hierarchy directory
  association [1]    to ZLR_CONNECTION_HIERARCHY_DIR as _dir        on  $projection.hieid = _dir.hieid


  // associations to the different node types
  // evalulated at runtime for each record in the order given here
  // first hit of ON-condition is followed
  // Differnce to old way of Hierarchy ZLR_CONNECTION_HIERARCHY - here no $projection.carrid   = ''  and $projection.connid   = '0000'
  association [1]    to ZOQ_CONNECTION_NODENAME      as _node       on  $projection.hieid    = _node.hieid
                                                                    and $projection.nodename = _node.nodeName
 

  // "nodatetype" Airline
  // Differnce to old way of Hierarchy ZLR_CONNECTION_HIERARCHY - here no  and $projection.connid = '0000'
  association [1]    to ZOQ_AIRLINE                  as _airline    on  $projection.carrid = _airline.carrid
 

  // association to dimension view
  association [1]    to ZLR_CONN                     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,

      // three different node types possible in this example
      // here CONNID is leaf (can not be derived from this view)
      
      @ObjectModel.foreignKey.association: '_airline'
      carrid,
      @ObjectModel.foreignKey.association: '_connection'
      connid,
      @ObjectModel.foreignKey.association: '_node'
      nodename,

      cast(
      case when carrid is initial and connid is initial then 'NODENAME'
           when connid is initial                       then 'CARRID'
           else 'CONNID' end as fieldname ) as nodetype,
  


      // associations defined above have to be exposed here
      // otherwise they will not be available
      _parent,
      _dir,
      _node,
      _airline,
      _connection
}

Hierarchy View

Hierarchy view can be defined using the following syntax.

Syntax:

...
[DEFINE] HIERARCHY hierarchy
         [parameter_list]
         AS PARENT CHILD HIERARCHY(
           SOURCE cds_view
           CHILD TO PARENT ASSOCIATION _hierarchy_assoc
           [PERIOD FROM field1 TO field2 VALID FROM from TO to]
           [DIRECTORY _directory_assoc FILTER BY cds_cond]
           [START WHERE cds_cond]
           SIBLINGS ORDER BY field1 [ASCENDING|DESCENDING][,
                             field2 [ASCENDING|DESCENDING], ...]
           [DEPTH depth]
           [NODETYPE node_type]
           [LOAD BULK|INCREMENTAL|load_option]
           [MULTIPLE PARENTS {NOT ALLOWED}|LEAVES|ALLOWED]
           [ORPHANS IGNORE|ERROR|ROOT]
           [CYCLES ERROR|BREAKUP]
           [GENERATE SPANTREE]
           [CACHE ON|OFF|FORCE])
     { element_list }

In Syntax

SOURCE – Name of Source view. The mandatory addition SOURCE specifies a CDS view entity. This source must expose the hierarchy association specified after CHILD TO PARENT ASSOCIATION in its SELECT list.

source

ZLR_CONN_HIERARCHY_BASE

CHILD TO PARENT ASSOCIATION: The mandatory addition CHILD TO PARENT ASSOCIATION specifies the hierarchy association who’s ON condition selects the descendant nodes of the root node set.

child to parent association

_parent

PERIOD FROM field1 TO field2 VALID FROM from TO to: The optional addition PERIOD defines the hierarchy as a temporal SQL hierarchy in which the hierarchy nodes are limited by an adjustment of time intervals. In case of parameter, they can be different but value must be same when used in a query. period from datefrom to dateto valid from $parameters.p_date to $parameters.p_date

period from datefrom to dateto valid from '20230425' to '20230425'

DIRECTORY: Hierarchy directory name. The optional addition DIRECTORY defines a filter condition cds_cond for the rows of the source of the hierarchy specified after SOURCE. It defines association to the header/ directory view. Filter can be defined on hierarchy directory, based on parameter. In case of time dependent hierarchy date parameters can be used to filter out the hierarchy.

_dir filter by hienm = $parameters.p_hienm1

and keydate = $parameters.p_keydate

START WHERE: The optional addition START WHERE specifies the start condition for creating the hierarchy. START WHERE can be followed by a logical expression cds_cond that selects rows from the source cds_view.

start where

parentid is initial

SIBLINGS ORDER BY field1 [ASCENDING|DESCENDING]: The mandatory addition SIBLINGS ORDER BY sorts sibling nodes in the hierarchy. Default is Ascending.

siblings order by

seqno

NODETYPE node_type: The NODETYPE identifies an element of the CDS hierarchy that can be used to determine the type of the hierarchy node. The values of this element must be element names, which must also be contained in the element list of the CDS hierarchy.

In context of Analytics, it is mandatory to define the nodetype field in the source view of the hierarchy and also in the hierarchy view using key word 'nodetype'

For example, in the Source view

cast(

case when carrid is initial and connid is initial then 'NODENAME'

when connid is initial then 'CARRID'

else 'CONNID' end as fieldname ) as nodetype,

In the Hierarchy view

nodetype

nodetype

More detailed information can be found here ABAP Keyword Documentation (sap.com).

Example of Hierarchy View

define hierarchy ZLR_CONN_HIERARCHY
  with parameters
    @Consumption.defaultValue: 'CNTRY'
    p_hieid : zoq_conhieid
  as parent child hierarchy(
    source ZLR_CONN_HIERARCHY_BASE
    child to parent association _parent
    directory _dir filter by
      hieid = $parameters.p_hieid
    start where
      parentid is initial
    siblings order by
      seqno
    nodetype nodetype
  )
{

      @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,

      nodetype, 
     
      // associations defined above have to be exposed here
      // otherwise they will not be available
      _parent,
      _dir,
      _node,
      _airline,
      _connection



}

Output

Red: association _node

Green: association _airline

Blue: association _connection, the blue marked records are leaves

Example of Query using Hierarchy

@AccessControl.authorizationCheck: #NOT_ALLOWED
@EndUserText.label: 'ZLR_CONN - query'
@Metadata.ignorePropagatedAnnotations: true

define transient view entity ZLR_CONN_QUERY
provider contract analytical_query
as projection on ZLR_CONN
{
@AnalyticsDetails.query:{
axis:#ROWS,
displayHierarchy: #ON ,
hierarchyBinding: [{ type: #CONSTANT, value: 'CNTRY'  }]

}
  connid
    
}

Output

Hierarchy View Using @ObjectModel.dataCategory: #HIERARCHY Annotation (OLD way)

In View definition the annotation @Hierarchy.parentChild provides the information about the parent child hierarchy. It has hierarchy name, multiple parents, recursion by, ordering of siblings, root node visibility, orphaned node handling, etc. along with that, following associations need to be defined.

Association to hierarchy view itself - It defines parent child relationship.
Association to hierarchy directory view - It contains all the header information, hierarchy Ids and the descriptions.
Association to different dimension/text views – It is a relation from the nodes and leaves to dimension and text views. Via this association the text of a node/leaf is derived. In the following example '_node' is first level node, '_airline' acts as second level node and '_connection' is leaf and pointing to dimension.

Important is the order of the associations listed in the element-list and the 'extra-condition' in the ON-clause. For each record of the hierarchy the ON condition of the associations is checked - the first association which meets the ON condition is used to get text and attributes for the hierarchy node/leaf.

One association is mandatory - its target must be the dimension view which has a ObjectModel.hierarchy.association to the hierarchy view. These objects in the hierarchy represent the leaves.

Example

@EndUserText.label: 'Connection Hierarchy View'
@ObjectModel.dataCategory: #HIERARCHY
@Hierarchy.parentChild: [{  
name : 'ConnectionHierarchy',
  label : 'Connection',
  siblingsOrder: [{ by: 'seqno' }] ,
  recurseBy : '_parent',
  directory: '_dir'
  }] 
  
define view entity ZLR_CONNECTION_HIERARCHY
  as select from zoq_connid_h

  // basic parent child relation inside one hierarchy
  // hierarchy uniquely selected (see @Filter for field HIEID
  association [0..1] to ZLR_CONNECTION_HIERARCHY     as _parent     on  $projection.parentid = _parent.nodeid

  // necessary if view represents several hierarchies
  // association to the hierarchy directory
  association [1]    to ZLR_CONNECTION_HIERARCHY_DIR as _dir        on  $projection.hieid = _dir.hieid


  // associations to the different node types
  // evalulated at runtime for each record in the order given here
  // first hit of ON-condition is followed
  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'

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

  // For which dimension this hierarchy belongs
  association [1]    to ZLR_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,

      // three different node types possible in this example
      // here CONNID is leaf (can not be derived from this view)
      
      @ObjectModel.foreignKey.association: '_airline'
      carrid,
      @ObjectModel.foreignKey.association: '_connection'
      connid,
      @ObjectModel.foreignKey.association: '_node'
      nodename,
      
      // associations defined above have to be exposed here
      // otherwise they will not be available
      _parent,
      _dir,
      _node,
      _airline,
      _connection

}

Output

Red: association _node

Green: association _airline

Blue: association _connection, the blue marked records are leaves

Reference

More information on @Semantics.signReversalIndicator can be found in the blog.

SAP Developer News, July 25th, 2024

2024-07-25T21:10:00.054000+02:00

Podcast Version: https://podcast.opensap.info/sap-developers/2024/07/25/sap-developer-news-july-25th-2024/

DESCRIPTION

ABAP CDS TechByte Series

ABAP CDS TechBytes – https://www.youtube.com/playlist?list=PL6RpkC85SLQC3HBShmlMaPu_nL--4f20z

SAP Build Code July Updates

Product Updates for SAP Build Code – July 2024 Edition https://community.sap.com/t5/technology-blogs-by-sap/product-updates-for-sap-build-code-july-2024-edition/ba-p/13764559

July Developer Challenge reminder

Blog post (containing links to each of the tasks) https://community.sap.com/t5/application-development-blog-posts/july-developer-challenge-quot-reverse-apis-quot/ba-p/13749653

UI5 Tooling 4.0 and Code Connect recordings:

UI5 Tooling 4.0: https://community.sap.com/t5/technology-blogs-by-sap/ui5-tooling-4-0/ba-p/13769578
reCAP Recordings: https://recap-conf.dev/
ui5Con Recordings: https://openui5.org/ui5con/germany2024/
ABAPConf Recordings: https://abapconf.org/abapconfeurope2024/

CAP #GoodToKnow Shorts Series

Modeling many-to-many associations #SAPCAP #GoodToKnow – YouTube https://www.youtube.com/shorts/yGg3YD1weIA
Series Playlist: https://www.youtube.com/playlist?list=PL6RpkC85SLQDZ18v94otZSJJrpcNkPPV9

================================================

CHAPTER TITLES

0:00 Intro

0:10 ABAP CDS TechByte Series

1:01 SAP Build Code July Updates

2:48 July Developer Challenge reminder

3:58 UI5 Tooling 4.0 and Code Connect recordings

4:55 CAP #GoodToKnow Shorts Series

TRANSCRIPTION

[Shilpa] Hello SAP developers, I'm sure by now you would have seen the new TechByte series on ABAP Core Data Services. If not, here's a quick recap. Myself and developer advocate Sheena will walk you through the basics of ABAP CDS, covering the overview and key functionality, how a virtual element with complex logic can be created, extend a CDS View Entity, restrict the data authorizations using CDS Access Control, govern the quality of CDS Views using unit test, and troubleshooting tools available to analyze the data of CDS Views. I will leave the link to the ten-part videos in the description. Not just that, the advanced features of ABAP CDS will be coming up, so stay tuned.

[Thomas] First shipped earlier this year, we have the introduction of SAP Build Code. This is the AI-powered latest version of SAP's development environment based upon the SAP Business Application Studio. This month we see enhancements to SAP Build Code, many of which are based right upon your feedback from initial use of Build Code. Most of the enhancements focus on the Joule AI integration.

First of all, we've made it easier to get to the Joule Assistant from within the storyboard and the graphical navigation tools of the CAP designer itself. The part that I'm most excited about is originally Joule integration in SAP Build Code was really focused on creating new CAP entities. So very useful when you're first starting your project. But we've heard your feedback and we've added a lot of new functionality that also lets you alter an existing CAP data model. So you can add new entities, add or remove associations, and make these changes to an existing model all using the same AI assistant that you've been using to start your projects. In addition to this major enhancement for the AI capabilities, we also see the addition of a guided assistant for Fiori development as well as a new graphical HDBGrants editor as well. So be sure to check out all the latest enhancements to SAP Build Code with the link in the show notes to the blog post that details them.

[DJ] The SAP Developer Challenge this month is well on the way. The challenge is called Reverse APIs, and it's all about you creating, creating CAP-based services and API endpoints for us to call and validate. We're about three quarters of the way through the challenge. There are 12 tasks altogether. So it sounds about right for this time of the month. So far, we've been digging into defining and implementing actions and functions in a couple of simple services across the REST protocol and the OData protocol adapters. And now we're moving more into a sort of Northwind-based service scenario, where we can try and flex our Odata muscles a bit more. It's not too late to get started. There's plenty of discussion and help in the SAP Community Platform for each of the tasks. So what are you waiting for? Head over to the SAP Community. The blog post link is in the description and get going.

[Nico] Hi everyone, and welcome to the SAP Developer News. The UI5 team just released version four of the UI5 tooling, which comes with some handy new features as well as paving the road for UI5 version 2.x, which is still in the works, but hopefully available soon. One of the new features is that the tooling can now generate the supported locales property of the manifest.json. So no more ugly 404s in production. Check out the blog post linked in the description for more information. On a related note, we would like to point our attention to the recordings of {CodeConnect}. They're now available on YouTube. So for UI5Con, reCAP, and ABAPConf, there are a lot of recordings available so you can check out the sessions on YouTube in your own time. Use the summer break wisely. All right, hope to see you soon, and bye.

[Thomas] I wanted to draw your attention to the recent series of YouTube Shorts, all with the tag #GoodToKnow. These are created by our fellow developer advocate, DJ Adams, and look at the basics of the SAP Cloud Application Programming Model. They do it in short 60-second chunks, and all formatted for easy consumption on a mobile device. This makes it easy to learn on the go, or just for those of you looking for some basic, but great CAP knowledge that you can consume in small, bite-sized chunks. In the most recent episode, DJ talks about many-to-many associations in the Cloud Application Programming Model. It's a concept that I thought would be difficult to explain and understand in 60 seconds, but DJ does a perfect job of it. So be sure to check out that latest video and the entire Good to Know series if you wanna learn more about the SAP Cloud Application Programming Model.