SAP Community - ABAP Development

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 13th 2024

2024-06-13T21:00:00.029000+02:00

ITEMS

ABAP Open Source Updates, ABAP2UI5 and apm

abap2UI5 - Integration with SAP Business Technology Platform (1/3) - Installation & Configuration https://www.linkedin.com/pulse/abap2ui5-integration-sap-business-technology-platform-13-installation-lf1re
abap2UI5 repository https://github.com/abap2UI5/abap2UI5
apm homepage https://abappm.com/

June Developer Challenge – Week 2

SAP HANA multi-model Developer Challenge: https://community.sap.com/t5/application-development-blog-posts/developer-challenge-sap-hana-multi-model-using-python-in-sap-business/ba-p/13722560
Developer Keynote at SAP TechEd 2023: https://www.youtube.com/live/kLbF0ooStZs?t=2145s
Business meets AI hackathon: https://events.sap.com/ch/hackathon2024/en/home

SAP Cloud Application Programming Model – May Release

Release notes https://cap.cloud.sap/docs/releases/may24

SAP BTP reference architecture for SAP Build Process Automation

Integrate and extend SAP and non-SAP solutions with SAP Build Process Automation https://discovery-center.cloud.sap/refArchDetail/ref-arch-build-process-automation
BTP Solution Diagrams https://sap.github.io/btp-solution-diagrams/

Two new SAP CodeTalk Podcast episodes, Frank Densborn and Riley Rainey

Frank Densborn episode Generative AP from the SAP Apphaus https://podcast.opensap.info/sap-developers/2024/05/28/sap-codetalk-frank-densborn-from-sap-apphaus-discussing-generative-ai-and-llms/
SAP AppHaus GenAI Explore workshop to identify AI use cases https://apphaus.sap.com/resource/generative-ai-explore-workshop
New AppHaus GenAI Discover/Design workshop with GenAI cards https://apphaus.sap.com/resource/generative-ai-discover-and-design-workshop
Riley Rainey episode on the SAP Developer Insights Survey Report https://podcast.opensap.info/sap-developers/2024/06/11/sap-codetalk-riley-rainey-discusses-the-sap-developer-insights-survey-report-with-josh-bentley/
Developer Insights Survey Report https://community.sap.com/t5/technology-blogs-by-sap/the-2024-developer-insights-survey-the-report/ba-p/13686151

New YouTube Shorts 60 second videos on CAP Node.js

The “CAP Node.js - Good To Know!” playlist https://www.youtube.com/playlist?list=PL6RpkC85SLQDZ18v94otZSJJrpcNkPPV9

CHAPTER TITLES

0:00 Intro
0:07 ABAP Open Source Updates, ABAP2UI5 and apm
1:39 June Developer Challenge – Week 2
2:42 CAP May Release
4:51 SAP BTP reference architecture for SAP Build Process Automation
5:36 Two new SAP CodeTalk Podcast episodes, Frank Densborn and Riley Rainey
7:04 New YouTube Shorts 60 second videos on CAP Node.js

TRANSCRIPT

This is the SAP Developer News for the 13th June 2024.

[Rich]
Hey folks, Rich Heilman here. I hope you all are doing well. This week, I'd like to share some news around the abap2UI5 project from our friend, Oblomov. He has posted on LinkedIn about the newly released abap2UI5 SAP BTP connector, which allows developers to call abap2UI5 apps via BTP from anywhere and integrate them into SAP Build Work Zone or SAP MobileStart. This is the first of a three-part series and in this post he explains the initial installation and configuration while sharing a bit about how the connector works. If you are a fan of abap2UI5 as I am, check out this latest post and learn about the abap2UI5 BTP connector today. Now while I have you, did you know that APM was launched last week at at the ABAP conference at Code Connect. Our friend Mark Bernard announced the availability of APM, an ABAP package management and registration tool. I don't have a whole lot of details to share right now, other than providing the website where you can check out the announcement video from the conference last week, and also review the presentation, and of course sign up for access to APM. I've done so already. I highly recommend for you to sign up yourself today. So check out the website for more information. Bye for now.

[Witalij]
Hi everyone, welcome from Zurich where we are having right now "AI Meets Business" hackathon. And I would like to introduce you to all the SAP colleagues who are coaches here. And now back to our regular update. It is great to see that quite many teams here at the hackathon are using SAP HANA Cloud Vector Engine. If you are participating in the Developer Challenge for this month, then you might see that the week 2 challenge is already posted, and this is where I'm inviting you to try Vector Engine yourself. We will be able to recreate the part of the demo, which I presented during our Developer Keynote at SAP TechEd, 2023. Happy coding and I'm looking forward to your submission.

[Tom]
We're happy to announce the May release of the SAP Cloud Application Programming model. This month we only have new features on the Java Runtime. This is because the CAP team is busy preparing for the big annual release, so expect major new things coming soon to the cloud application programming model. In the meantime, the CAP version this month has several new features that we'll highlight. First of all, there's a new difference processor. This is an API that can compare two entities and will tell you the differences. It can be really useful if you're wanting to, for instance, track changes at two different states of the same entity. We also see with the built-in change tracking now through an annotation, you can specify what key you want to be recorded in the change track. So instead of the technical key, you could perhaps store the business key. We see a new beta feature for fuzzy HANA search. We also have a new feature for setting the max age of an HTTP response via annotation. particularly useful when you have a MIME response. And we have the OData v4 key as a segment. This helps with building and simplifying the URL parameters for keys when requesting an OData entity. And finally there's a feature that I hope will be coming to the JavaScript version as well and that's the new Developer dashboard. Now this is an alpha version of the developer dashboard and it contains all kinds of cool information that helps you during the development process. Now the the notes are really clear that you should never use this in production because it would expose sensitive data. It looks like an incredible new developer tool and I can't wait to check it out. So all these great new things coming to the Java version of CAP in the May release and keep your eye out for the big major release coming soon for the Cloud Application Programming Model as well.

[DJ]
Are you working with the SAP Business Technology Platform? Then if so, this news item is for you. The reference architecture for SAP Build Process Automation has been released. There's a wealth of resources collected together on this reference architecture over on the SAP Discovery Center. Not only that, but if you're building BTP solution diagrams, there's a repository with a starter kit, examples, and guidelines, as well as templates for you to use that are in draw IO format. Links to the SAP Discovery Center page and the GitHub repository are in the description.

[Josh]
Hey everybody, Mr. Bluebeard, Josh Bentley, And I'm here to give you a couple of updates real quick on the SAP CodeTalk podcast series. I was lucky enough to get to do two podcast episodes recently. The first was with Frank Densborn and he's from our SAP AppHaus team. The AppHaus co-innovates with our customers. They dive deep on a use case and they come up with some code that actually can solve that use case problem. So Frank Densborn goes through this with me in the podcast episode and then he goes down to SAP Sapphire in Orlando and dives deeper with the customers on how we're using large language models and chatGPT and generative AI to solve some of these use cases. So very topical and very cool stuff that Frank and the team at the AppHaus are putting out. The next episode I recorded was with Riley Rainey. Riley is from our developer advocates team and he helps put out the Developer Insight Survey. So if you see that survey coming out and you fill in those questions with your answers, We actually take that back to the committee and we go through those answers and put out a report and Riley goes through the methodology and some of the most recent answers that were given in the Developer Insight Survey. So link to that below in this Developer News episode and if you're not already subscribing to the SAP Code Talk podcast, wherever you listen to podcasts, please subscribe and also you can keep watching it here on the SAP Developer YouTube channel. And finally, happy Pride Month. Bye.

[DJ]
The developer advocates are always looking for new ways to help developers. With that in mind, we've started creating some YouTube Shorts. A Short is in portrait format, no more than 60 seconds, which is basically then ideal for consuming quickly, on the go, on your phone. The current series is on CAP Node.js with tips and tricks that are good to know. For example, this week's short, just released, is all about the @Path annotation for service definitions. There's a link to the entire playlist so far in the description, so head on over there and check them all out.

Cleaning up the core and using events to decouple your enhancements

2024-06-18T12:25:38.779000+02:00

Sometimes I worry that SAP are in danger of leaving us all behind. It seems that they are on a starship shooting off at light speed to the stars of Generative AI and cloud everything. SAP customers meanwhile are still trying to get their on premiss SAP ECC biplanes off the ground. I know that SAP have to do this, as they have to stay ahead of the game, to compete, and they currently do this through focussing on BTP, and all the goodies around this, and then incorporating generative AI is all the buzz at the moment. Yet the majority of SAP customers are mostly wrestling with how they will upgrade to S/4 before the deadline of 2027. I understand that SAP must be innovation focussed and so it often falls to SAP tech architects working for customers or SAP partners to ensure that customers can stay on track with their vision to someday catchup to where SAP are at (by which point in time SAP will be somewhere else probably in a far away galaxy😉).

“Keep the core clean” has been the SAP mantra now for at least 6 years and probably for a lot longer, I personally first remember it from Teched 2018 in Barcelona. As a software engineer I read “keep the core clean” instead as “decouple your custom code from the standard solution”, admittedly its not as catchy...

As many SAP customers are still preparing for S/4 upgrades, then many customers are still in the stages where cleaning up the core is very much a key focus area.

What you as an SAP customer can do to prepare for cleaning the core varies a bit depending on where you are in your SAP journey.

Keeping the core clean does not have to be done pre-S/4 – but it should make life simpler, the sooner you start, and what you are essentially doing is cleaning up your technical code debt.

If you are pre S/4 upgrade, I would begin with the quick wins, and this is by focussing on enhancement code that is often simply not encapsulated at all, and so not coded using ABAP Objects, and called from within SAP enhancement points, BADIs or user exits.

Probably the best approach is to focus on encapsulating all your enhancements, ensuring that it is relatively simple to relocate them when the need arises, ensuring there is a clear, well scoped boundary from where standard code ends and custom code begins. Following clean code principles and using SOLID OOPs design techniques enables you to begin to decouple your deeply embedded custom code, in preparation for a future redesign, and or relocation to BTP.

My own experience with custom code from various SAP customers over the years, means that I suspect that many enhancements are just loosely coded ABAP code placed directly wherever the functionality is needed, often with little thought to encapsulation, this kind of code is essentially code debt. Cleaning this code up will help to make your S4 upgrade journey smoother and simpler, or if you are on S/4 it could make your future journeys considerably smoother.

So the main principles are quite simple object oriented principles, that Robert C Martin is famous for defining.

Aim for Single responsibility in the classes that you introduce. Think carefully about their interfaces, their contract to the places that call them, exposing the bare minimum as public, but enough to allow for long term requirements. Try to unknit your spaghetti code, into purposeful methods that don’t do too much. Aim to keep code simple. Don’t be afraid to create additional classes if a class is doing too much work, if its losing its singular responsibilities.

Its often useful to define interfaces that the classes then implement, the interface is then defining a public contract, and can also be useful for unit testing purposes, and the creation of test-doubles. Using interfaces creates a layer of decoupling, and definition, that introduces future flexibility into your solution.

We need to take a methodical approach to all of our enhancements, and slowly redesign them by these simple decoupling techniques.

One of the purposes of this blog is to point out an approach to decoupling that I only fairly recently stumbled upon. This is through using events via ABAP message channels, together with ABAP Daemons, something which Olga has described in a blog back in 2015 and then again in 2018, and also gets a passing mention in ABAP to the Future (Paul Hardy SAPPress) Olga’s blogs are here:

https://community.sap.com/t5/application-development-blog-posts/introduction-to-abap-channels/bc-p/13097526

https://community.sap.com/t5/application-development-blog-posts/abap-daemons-always-available-abap-sessions-to-handle-events/ba-p/13380833.

This approach only becomes relevant when you are on an S/4 system, as it requires 7.52 as well as 1809. With this approach, you can for example, raise an event in an enhancement point, and then subscribe to the event from a custom class that is then triggered by an ABAP Daemon process. The daemon processes are considered robust by SAP from 1809 onwards – in that they get restarted if the system is restarted, and events are not at risk of being lost. So switching your enhancements to an event driven programming model really takes another step towards decoupling your custom code to the standard SAP code.

This kind of design means the enhancement is solely used to raise an event and pass the necessary information onto the subscribing class. This means your implementing class for your enhancement is almost fully decoupled. Ready to be migrated to the possibility of a BTP solution or alternative solution. I was quite surprised to find this great possibility was there and I simply hadn’t realised it was there, so I mention it here in the hope to spread the news a little further. Further down this road we have Event mesh and the possibility then to use events for external interfaces, I think many are aware of the event mesh approach, but perhaps less aware that events can be built straight into regular ABAP (this at least was the case for me and a few colleagues that I have talked with).

As always there are pros and cons to this approach. The pros I think are as mentioned, the looser coupling, tied then to all the advantages loose coupling brings (increased future flexibility), one of the cons comes down to the need for atomicity. If you for instance need to update a custom table within the same logical unit of work as the SAP code, then this approach will not allow for that, but I would argue that you probably should not need to be this tightly coupled to SAPs updates, this kind of thinking is what we need to move away from to keep the core clean. The other con being what if the event handling fails. Well we are told that this approach is quite robust now with 1809 support for ABAP Daemons, and so most of the negatives of this approach I think are laid to rest.

In my next blog (probably a month or two away) I want to focus on the enhancement options that SAP are providing for cleaning the core in S/4, and their defined methodologies that are there for helping customers decide for what solution is best for them, and how this fits in with your decoupling efforts.

Clean Core: custom checks in a Production Order

2024-06-20T17:33:42.157000+02:00

I recently came across an interesting thread in the SAP Community, where a user was asking if he can block users to change the production order quantity. I think that this is the perfect business requirement to demonstrate how we can implement a simple custom logic that is compliant with the clean core approach.

Note: If you are not familiar with clean core, I suggest that you go through the following learning journey: https://learning.sap.com/learning-journeys/practicing-clean-core-extensibility-for-sap-s-4hana-cloud/introducing-the-clean-core-approach_fcb6c662-7041-4c99-88bd-345636fae7f3

SAP S/4HANA 2023 Private Cloud Edition introduced the new Fiori App Custom Logic (F6957), which allows us to create implementation of BAdIs that were released by SAP and that are clean core compatible.

You can access this app in the Fiori Launchpad if role SAP_BR_EXTENSIBILITY_SPEC is assigned to your user.

In this blog we will use this app to create a new implementation of BAdI Manufacturing Order Check Before Save – BD_MFGORDER_CHECK_BEFORE_SAVE, and we will introduce a new check that will throw an error message whenever an user tries to change the order quantity, after the order creation.

The first step to create our BAdI implementation is to launch this app in the Fiori Launchpad. We will then see a list of the existing BAdI implementations, which can be managed in the app. We will then click the button Create to generate a new BAdI implementation.

In the following screen, we will search for the extension point that will be used for our custom logic, and if we search by MFGORDER, we can find all the extension points available for manufacturing orders.

We can find more information about each one of the extension points by clicking button View Documentation, where a popup screen will be shown with additional details about the BAdI, as we can see in the figure below:

Step 2 is not relevant in this example, as don’t need connectors or filters, so we can go straight to step 3, where we will define the Implementation ID and provide a description.

After that, we should click button Review, and we will be able to see all the information about the New Implementation in a single screen. Here, we can proceed with the creation by clicking button Create.

With our implementation created, we need to publish it, by clicking the button Publish (might take a few seconds), and we will finally be able to branch in the editor, by clicking the Open Code Editor button.

The code editor is quite simple, and we have the code in the left side, and the available parameters in the right side. If we click the button Show Sample Code, we can see a popup screen with a sample implementation provided by SAP, as we can see below. The code of this sample implementation is very simple, and there are comments to make it easily understandable.

I have copied the code provided from SAP, and adapted it to create my own implementation, where I’m going to compare the new order quantity with the old order quantity and thrown an error message when they are different.

Here is the code of my BAdI implementation:

*   only perform the implementation for order category is "Production Order"
    CHECK manufacturingorder-manufacturingordercategory = if_mfgorder_check_before_save=>con_productionorder.

*   check if the production order quantity has been changed
    IF manufacturingorder-MFGORDERPLANNEDTOTALQTY <> manufacturingorder_old-MFGORDERPLANNEDTOTALQTY AND
       manufacturingorder_old-MFGORDERPLANNEDTOTALQTY <> 0.
*           add the an error message with helpful information to the message table
            INSERT VALUE #(
                     messagetype = 'E'
                     messagetext = |Production order quantity cannot be changed| ##NO_TEXT
                   ) INTO TABLE messages.

    ENDIF.

Here, it is important to mention that this editor uses Restricted ABAP, which does not support all the features originally available in ABAP. This blog provides more details about Restricted ABAP and the supported features.

Whenever we finish the code, we can click button Save and Publish to activate our implementation.

With our implementation published, we can go to transaction CO02 and try to change the order quantity, to see what will happen. As shown in the figure below, an error message is triggered if we try to save an order with a different quantity.

This is just a very simple example, used to demonstrate how the Fiori App Custom Logic can be used to implement custom checks in a production order, but you can use it as a starting point for your own implementation. For example, you can add a tolerance for the quantity change, you can allow changes for orders that are not released, or you can add any check that your business need.

Brought to you by the SAP S/4HANA RIG

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

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:

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.

ST05: Application Programming Interface

2024-06-26T11:32:10.598000+02:00

After a little more than one year I am now adding one more blog post to my series Use ST05 to Analyze the Communication of the ABAP Work Process with External Resources. All previous blog posts in this sequence have assumed that you work interactively with dialog transaction ST05 to start and stop trace recording and to display and analyze the resulting traces. However, there may be circumstances where this approach is inconvenient, cumbersome, or outright impossible. Examples are requirements where you need to monitor regularly or even frequently the communication of multiple applications with external resources. This is certainly beneficial for the detection of regressions early in the development process so that you can counteract immediately. In other cases you may want to very restrictively limit the tracing to dedicated parts of your application which you suspect to use external entities in a way that impairs performance or scalability. In all these situations you want to use the API functions that come with the ST05 software. They are contained in function group ST05_API within SAP_BASIS, also known as ABAP Platform.

In this blog post I cover the most important of these API functions and describe their intended use. The focus is very much on the technicalities of using the APIs. Please refer to my other blog posts in the series for an explanation of the semantics of the provided data.

The functions can be subdivided into three categories:

Functions that deal with the activation or deactivation of tracing.
Functions that retrieve trace records with a level of detail or aggregation that best supports your intended investigation.
Functions that permanently store trace records in the system's database or on your local hard disc.

Trace Recording

Let me begin with functions related to writing the trace records, especially the complementary pair of functions to start and stop trace recording.

ST05_Activate_Trace

With this remote-enabled function you switch tracing on. Through the function's IMPORTING parameters you specify the communication interface you want to monitor, and you set filter criteria for the events to be covered. Functionally, the parameters cover everything that is available via the SAP GUI option Activate Trace with Filter described in my blog post Activate Trace Recording with Filter. Please visit this post for a more comprehensive explanation of the supported filter conditions.

TRACE_TYPES TYPE ST05_API_TRACE_TYPES
With this mandatory parameter you define the trace types, i.e., the communication channels, you want to monitor. Structure ST05_API_TRACE_TYPES contains Boolean fields (TRUE = 'X' ; FALSE = ' ') for all trace types supported by ST05 (SQL, BUF, ENQ, RFC, HTTP, APC, AMC), and additionally for the authorization trace (AUTH) covered by ST01. The fields are called <type>_ON. At least one trace type must be selected, otherwise the call of the function ends with exception MISSING_TRACE_TYPE.
TRACE_FILTER TYPE ST05_API_TRACE_FILTER
This optional parameter allows you to precisely filter individual communication events triggered by the application which shall be traced. The default imposes no restrictions. The TRACE_FILTER consists of fields:
1. CLIENT TYPE SYMANDT
  This is very new. Previously, trace recording was not client-specific but always cross-client. Now (ABAP Release 9.12 (quarterly) / 8.16 (biennially); ABAP platform 2408 (cloud) / 2025 (classic); Kernel Release 9.12) you can define the client via this field. With a closing wildcard (e.g., 00*) you can activate tracing on multiple clients matching the given pattern.
2. TRACE_USER TYPE ST05_USER_NAME_PATTERN
  This field limits the trace activation to the specified back-end user. Only her or his activities are recorded. User name patterns with the asterisk * as a terminating wildcard character are supported.
3. TRANSACTION_CODE TYPE PTC_TRANSACTION_CODE
  PROGRAM TYPE PTC_PROGRAM_NAME
  RFC_FUNCTION TYPE ST05_RFC_FUNCTION_NAME
  URL TYPE ST05_URL
  With this group of four fields, you can limit the captured events to those that are triggered while executing a particular application. Because this application must be at the very top of the call hierarchy, you may give a value for at most one of the fields. Patterns with the asterisk * as a terminating wildcard are allowed.
4. WP_ID TYPE PTC_WP_ID
  Setting the WP_ID field confines the trace recording to events called from the given ABAP work process. This is hardly ever useful in an API call, i.e., there the benefit of this filter criterion is even smaller than in the SAP GUI dialog option Activate Trace with Filter.
5. INCLUDED_TABLES TYPE ST05_OBJECT_INCL_EXCL
  EXCLUDED_TABLES TYPE ST05_OBJECT_INCL_EXCL
  INCLUDE_MISSING_TABLE_NAME_ON TYPE PTC_BOOLEAN
  For an SQL trace, you can restrict the recording of SQL statements to those that work on certain database tables (or database views, including CDS views). You may define up to 5 tables to be included. Similarly, you can exclude up to 5 database tables. Statements accessing these excluded tables will then not be recorded. For both options, you may filter on groups of tables by terminating entries in fields INCLUDED_TABLES or EXCLUDED_TABLES with an asterisk *. For implemented Open SQL JOINs, the table name filter applies to the first of the JOINed database tables. If a database table matches entries in both fields INCLUDED_TABLES and EXCLUDED_TABLES, SQL statements against this table will not be recorded.
  If you specify a table in the INCLUDED_TABLES, and also want to trace all statements that do not directly affect an individual table (e.g., COMMITs, ROLLBACKs, SET SESSION VARIABLE, SET CLIENT INFO), you must set the Boolean field INCLUDE_MISSING_TABLE_NAME_ON to 'X'.
6. STACK_TRACE_ON TYPE PTC_BOOLEAN
  With this field you determine whether the trace records shall contain the ABAP call hierarchy for the recorded events. The advantages (and disadvantages) of this option are described in detail in my blog post ST05: Basic Use. For use cases that call the ST05 APIs, the stack trace is typically not needed, and you should not request it to minimize the trace recording overhead.
ALL_SERVERS TYPE PTC_BOOLEAN
By default, function ST05_Activate_Trace starts trace recording only on the server where it is running. With the optional Boolean parameter ALL_SERVERS you can request the activation on all application server instances of the system. This works like the option <ALL> for field Instance in the filter conditions popup when you Activate Trace with Filter in ST05.

Via EXPORTING parameter SERVER_INFORMATION_TABLE (of TYPE ST05_SERVER_INFORMATION_TABLE), function ST05_Activate_Trace reports back to its caller where tracing was activated (fields INSTANCE and HOST) and when (fields DATE and TIME). Field IS_LOCAL marks the application server instance where the function was executed. The GUID will always be initial, i.e., a string of 32 zeros.

Through several EXCEPTIONS, function ST05_Activate_Trace informs its caller if errors occurred during its runtime.

NO_AUTHORITY
The user has insufficient authorizations. Required is value ST0M for field S_ADMI_FCD in object S_ADMI_FCD .
MISSING_TRACE_TYPE
No trace type has been selected, i.e., IMPORTING parameter TRACE_TYPES is INITIAL.
NO_CROSS_CLIENT_TRACING
Cross client tracing from an application client to another client is forbidden. An application client is recognized if a call to method cl_system_client_check=>is_system_client( ) returns ' ' (blank). This is relevant only in systems with tenant separation.
USER_MISMATCH
Tracing is already active for another user. It is not possible to change this user without first completely deactivating the trace recording.
ACTIVATION_ERROR
Trace recording cannot be activated for other reasons.
NO_SERVER_LIST
This exception is not yet used, i.e., never RAISEd.
INTERNAL_ERROR
Some internal error prevented the trace activation.

ST05_Deactivate_Trace

With this remote-enabled function you switch tracing off. Functionally, it corresponds to the SAP GUI options Deactivate Trace or Deactivate Trace on All Instances.
With the function's IMPORTING parameters you precisely control what the trace deactivation shall achieve.

TRACE_TYPES TYPE ST05_API_TRACE_TYPES
ALL TYPE PTC_BOOLEAN
With an appropriate combination of these two optional parameters you specify the trace types for which you want to deactivate the recording. Typically, this will be the set of trace types you have previously passed into function ST05_Activate_Trace. Then it will be convenient to set ALL to 'X' and leave TRACE_TYPES initial. This is also the approach to establish clean initial conditions where all components of the System Trace (ST01) are switched off - even those not accessible to ST05. If you want to deactivate tracing only for a subset of the currently monitored communication channels, set the corresponding fields in TRACE_TYPES to 'X'. Do not let the field names of structure ST05_API_TRACE_TYPES confuse you: they are called <type>_ON, but function ST05_Deactivate_Trace will switch off the recording when they are set to 'X'.
If both, TRACE_TYPES and ALL, are initial, the function will terminate with exception MISSING_TRACE_TYPE. If ALL is set to 'X', it will overwrite whatever is passed into ST05_Deactivate_Trace with parameter TRACE_TYPES, i.e., then the content of this parameter will be ignored.
ALL_SERVERS TYPE PTC_BOOLEAN
If you set this optional parameter to 'X', trace recording will be switched off on all application server instances of the system.
ALL_USERS TYPE PTC_BOOLEAN
If this optional flag has the value 'X', the selected TRACE_TYPES will be deactivated, independent of who activated them. Otherwise and if the trace recording was activated by another user, the function will terminate with exception DEACTIVATION_ERROR.

As with function ST05_Activate_Trace, the EXPORTING parameter SERVER_INFORMATION_TABLE (TYPE ST05_SERVER_INFORMATION_TABLE) informs callers of function ST05_Deactivate_Trace where tracing was deactivated (fields INSTANCE and HOST) and when (fields DATE and TIME). Field IS_LOCAL marks the application server instance where the function was executed. The value of the GUID field identifies the trace directory entry corresponding to the just ended trace recording. Please refer to my blog post Trace Directory for more details on this component of ST05.

Similar to ST05_Activate_Trace, function ST05_Deactivate_Trace communicates errors to its caller by several EXCEPTIONS:

NO_AUTHORITY
The user has insufficient authorizations. Required is value ST0M for field S_ADMI_FCD in object S_ADMI_FCD .
MISSING_TRACE_TYPE
No trace type has been selected, i.e., IMPORTING parameters TRACE_TYPES and ALL are INITIAL.
DEACTIVATION_ERROR
Trace recording cannot be activated for other reasons.
Example: Tracing was activated by another user and parameter ALL_USERS was not set.
NO_SERVER_LIST
This exception is not yet used, i.e., never RAISEd.
INTERNAL_ERROR
Some internal error prevented the trace deactivation.

Pseudo code for a typical scenario that uses these two functions:

CALL FUNCTION 'ST05_ACTIVATE_TRACE' ... .
    Execute some part of the application
    which communicates with external resource
    in a potentially critical way.
CALL FUNCTION 'ST05_DEACTIVATE_TRACE' ... .

If you have passed appropriate arguments into functions ST05_Activate_Trace and ST05_Deactivate_Trace, you have recorded traces of your application's accesses to external resources. The corresponding trace records are stored in the file systems of the application server instances. From there you can fetch the traces for detailed analyses as described in the following section Trace Analysis.

ST05_GET_TRACE_STATE

This function (also remote-enabled) is closely related to the two functions explained above. It retrieves the current trace state from the application server instance where it was called. You would use it to convince yourself that it is possible and safe to call function ST05_ACTIVATE_TRACE without interfering with ongoing trace recordings of other users, or to double-check that previous calls to ST05_ACTIVATE_TRACE or ST05_Deactivate_Trace were successful.
The function's sole EXPORTING parameter TRACE_STATE of type ST05_TRACE_STATE has the components

CLIENT TYPE SYMANDT
TRACE_USER TYPE ST05_USER_NAME_PATTERN
MODIFICATION_USER TYPE SYUNAME
Name of the user who has last changed the trace state on the local application server instance.
MODIFICATION_DATE TYPE DATS
MODIFICATION_TIME TYPE TIMS
Date and Time when the trace state was last changed on the local application server instance.
TRACE_TYPES TYPE ST05_TRACE_TYPES
FILTER_ON TYPE PTC_BOOLEAN
Flag to indicate whether trace recording was activated with filter.
TRANSACTION_CODE TYPE PTC_TRANSACTION_CODE
PROGRAM TYPE PTC_PROGRAM_NAME
RFC_FUNCTION TYPE ST05_RFC_FUNCTION_NAME
URL TYPE ST05_URL
WP_ID TYPE PTC_WP_ID
INCLUDED_TABLES TYPE ST05_OBJECT_INCL_EXCL
EXCLUDED_TABLES TYPE ST05_OBJECT_INCL_EXCL
INCLUDE_MISSING_TABLE_NAME_ON TYPE PTC_BOOLEAN
STACK_TRACE_ON TYPE PTC_BOOLEAN
PROGRESS_INDICATOR_ON TYPE PTC_BOOLEAN
This flag has no meaning any more.

Structure components that are not explained in the above list correspond to the matching fields of the IMPORTING parameter TRACE_FILTER of function ST05_ACTIVATE_TRACE. They are described above.

Trace Analysis

Let me now move on and continue with the API based processing and analysis of previously recorded traces. Three functions support different levels of detail for your investigation. I have already explained the available aggregation options in my blog post Aggregate Trace Records. The most comprehensive function is ST05_GET_TRACE_TABLES, which supplies internal tables of trace records for all supported degrees of aggregation plus the raw format of the ABAP call stack. Function ST05_GET_SUMMARY_TABLES focuses on the summarized trace records, and function ST05_GET_TABLE_ACCESS_RECORDS only provides the database table access trace records.
Functions ST05_GET_TRACE_TABLES and ST05_GET_SUMMARY_TABLES have the same IMPORTING parameters, a subset of which is also available to ST05_GET_TABLE_ACCESS_RECORDS.

TRACE_TYPES TYPE ST05_TRACE_TYPES
Specify the trace types you are interested in by setting the corresponding flags <type>_ON to 'X'. The flags AUTH_ON and ST01_ON have no effect.
TRACE_INTERVAL TYPE ST05_TRACE_INTERVAL
Indicate the trace period by giving its START_DATE and START_TIME, and its END_DATE and END_TIME. You will typically fill these fields with values obtained from functions ST05_Activate_Trace and ST05_Deactivate_Trace via their EXPORTING parameter SERVER_INFORMATION_TABLE.
(Fields START_MS and END_MS allow to set the beginning and end, respectively, of the trace interval to milli-second precision. They are hardly ever meaningful.)
READ_FILTER_CONDITIONS TYPE ST05_READ_FILTER_CONDITIONS
With this parameter you restrict the set of trace records to those that are associated with EPP root context IDs contained in EPP_ROOT_CONTEXT_ID_RANGE. This is of limited value because you seldom know the EPP root context ID, and if you have managed to "very restrictively limit the tracing" almost all trace records will have identical EPP root context IDs.
GUID TYPE SYSUUID_X16
If you specify this parameter, the corresponding trace directory entry will be processed. The GUID takes precedence over the TRACE_TYPES, TRACE_INTERVAL, and READ_FILTER_CONDITIONS parameters.
If flag SAVE_TO_DB is set, and there is not yet a trace directory entry that permanently stores the trace records in the database, it will be created and identified with this GUID.
KIND TYPE CHAR4
Control the level of detail or aggregation of the trace records to be provided by the API functions. Possible values are
1. CDS
  statistics on CDS view usage
2. ALL (default)
  all of the following levels
3. MAIN
  main trace records
4. DET (not supported by function ST05_GET_SUMMARY_TABLES)
  detailed trace records
5. DET+ (not supported by function ST05_GET_SUMMARY_TABLES)
  detailed trace records plus kernel format of the ABAP call stack
6. STRU
  structure-identical trace records
7. VAL
  value-identical trace records
8. TAB
  table accesses trace records
ACCEPT_INCOMPLETE_TRACE TYPE PTC_BOOLEAN
As I have described in my blog post Technical Background of Trace Recording and Analysis, a trace may be partially overwritten due to the round-robin approach used internally for the trace file administration. The default behaviour of the ST05 API functions in this case is to return no trace records at all. You can overrule this by setting the flag ACCEPT_INCOMPLETE_TRACE to 'X'. Then the functions will supply all appropriate trace records that are still available.
SAVE_TO_DB TYPE PTC_BOOLEAN
Set this flag if you want the trace records to be stored in a trace directory entry on the database to ensure that they are not overwritten.
This is a special option for dedicated internal purposes. If you wish to save trace records to the database I advise you to instead use the generic function ST05_SAVE_TRACE, which I describe below in section Trace Administration.

Function ST05_GET_TABLE_ACCESS_RECORDS does not support IMPORTING parameters READ_FILTER_CONDITIONS, KIND, and SAVE_TO_DB, but offers the Boolean flag CONDENSE. If set to 'X', INSERTs, DELETEs, UPDATEs as well as various buffer accesses to a database table will be summarized.

The functions' EXPORTING parameters provide trace records in ABAP internal tables to their callers. Please refer to my Aggregate Trace Records blog post for an explanation of the fields in the underlying structures.

DETAILED_RECORD_TABLE TYPE ST05_DETAILED_RECORD_TABLE
This internal table does not summarize the trace records, thus can support all conceivable investigations.
MAIN_RECORD_TABLE TYPE ST05_MAIN_RECORD_TABLE
I have described the purpose and the most relevant fields of this level of aggregation in my Basic Use blog post.
STRUCTURE_ID_RECORD_TABLE TYPE ST05_IDENTICAL_RECORD_TABLE
For many types of investigation this is the appropriate level of detail. It perfectly balances the available information granularity with the size of the internal table. It also augments the trace records with meta data on the accessed database tables.
VALUE_ID_RECORD_TABLE TYPE ST05_IDENTICAL_RECORD_TABLE
Use this internal table to detect redundant accesses to database tables. They fetch identical result sets from the database. This creates unnecessary load on the central database server and slows down the application. Please note that superfluous database accesses do not necessarily lead to value-identical trace records, i.e., even if VALUE_ID_RECORD_TABLE is empty, the traced application may need some performance optimization.
TABLE_ACCESS_RECORD_TABLE TYPE ST05_TABLE_ACCESS_RECORD_TABLE
This internal table aggregates SQL trace records corresponding to statements of the same category (e.g., SELECT, INSERT, UPDATE, DELETE) that access a table or view. It also summarizes BUF trace records that access an object with the same number of key fields. Other trace types are not covered.
KERNEL_CALL_STACK TYPE ST05_KERNEL_CALL_STACK
This is the raw format of the ABAP call hierarchy. As I have already mentioned, it is not relevant for the typical use cases that call the ST05 APIs, and you should not even record it.
TRACE_DIRECTORY_ENTRY TYPE PTC_DIRECTORY_ENTRY
This is only available if the IMPORTING parameter GUID was specified. Then it contains the corresponding entry from the trace directory. For the use cases covered in this blog post, it is not relevant.
INCOMPLETE_TRACE TYPE PTC_BOOLEAN
If the functions set this Boolean flag to 'X', the trace and therefore the internal tables are potentially incomplete. You want to repeat the trace recording with a more restrictive filter passed into function ST05_Activate_Trace.

Function ST05_GET_SUMMARY_TABLES does not support EXPORTING parameters DETAILED_RECORD_TABLE and KERNEL_CALL_STACK.
Function ST05_GET_TABLE_ACCESS_RECORDS only offers EXPORTING parameters TABLE_ACCESS_RECORD_TABLE and INCOMPLETE_TRACE.

Trace Administration

With functions ST05_SAVE_TRACE and ST05_EXPORT_TRACE you can save sets of trace records to the trace directory on the database or export them to your local front end file system, respectively. In either case, this will persist the trace records so that you can analyze them even when they are no longer in the application server instance's file system.

Both functions offer IMPORTING parameters TRACE_TYPES and TRACE_INTERVAL as described above.

If you specify a DESCRIPTION when calling ST05_SAVE_TRACE, this will be used for the trace directory entry. If you leave the DESCRIPTION empty, the user will be prompted in a dialog to describe the set of trace records.
Function ST05_SAVE_TRACE supports Boolean flags ACCEPT_INCOMPLETE_TRACE and ALL_SERVERS. If you set ALL_SERVERS = 'X' the function will go through all application server instances and save trace records that match the filter criteria into individual trace directory entries.

With function ST05_EXPORT_TRACE you may specify a GUID of a trace that is already stored in the trace directory. This trace will then be exported to your hard disc, and parameters TRACE_TYPES and TRACE_INTERVAL will be ignored.
With the FORMAT parameter you can determine whether the trace shall be exported in binary format ( value 'BIN', suitable for later re-import and further analysis with ST05), or in ASCII format (value 'CSV_*', where * indicates the aggregation level), e.g., for subsequent analysis with spreadsheet software.
The FILE_NAME parameter will be used to name the file on the front end. If no name is passed into function ST05_EXPORT_TRACE, it will prompt the user.

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

ABAP SDK for IBM watsonx v1.1.0 released

2024-06-28T16:09:55.197000+02:00

On March 28, 2024, IBM had published the first release of its ABAP® Software Development Kit (SDK) for IBM® watsonx™ services. The IBM watsonx AI and data platform brings together new generative AI (gen AI) capabilities powered by foundation models and traditional machine learning (ML). Using IBM Watson Machine Learning, you can build analytic models and neural networks, trained with your own data, that you can deploy for use in applications. Using IBM watsonx.ai, you can run text inference and more on Large Language Models (LLM). The SDK provides a class library that can be downloaded to SAP systems using abapGit and comes in two flavors:

ABAP SDK for IBM watsonx, using SAP NetWeaver for the SAP Business Suite running on SAP NetWeaver 7.50 or above and for the SAP S/4HANA on-premises edition.
ABAP SDK for IBM watsonx, using SAP BTP ABAP Environment for the SAP Business Technology Platform ABAP Environment.

On June 27, 2024, version 1.1.0 of the SDK was released by IBM. Enhancements in this release include a new method Text_Embeddings for the watsonx.ai service and the support of various update methods in the Watson Machine Learning and watsonx.ai services for SAP NetWeaver AS ABAP 7.50+. More information about the changes in version 1.1.0 can be found in the repositories in the migration document MIGRATION-V1.1.0.md.

Detailed information on how to setup and use the SDK can be found in the README.md files of the GitHub repositories. The README.md files also provide two comprehensive examples to show how the supported services can be used. An even more elaborated article about how use watsonx services with the ABAP SDK can be found in Joachim Rese's blog article How to Bring Generative AI to Your ABAP Program Using the ABAP SDK for IBM watsonx.

Full screen list in Maintenance Views

2024-07-03T09:30:06.101000+02:00

Introduction

Hi and welcome to my next SAP Community blog post.

With or without Fiori in the picture, Maintenance View is one of the main tools for maintaining SAP configuration. Reliable and easy to use, it is a proverbial workhorse.

However, since widescreen monitors became a standard, it has always been frustrating to me to see how much space is left unused (not to say wasted) in the list of a Maintenance View. The obvious solution was to modify the screen manually, but this was overwritten whenever a list was recreated.

Today, I will show you a way of making the Maintenance View list use as much space as possible, always.

Implementation

To achieve this, a modification has to be done to a standard SAP include responsible for creating the screen. The include is called MSVIMF21.

The list screen is created by a function call RPY_DYNPRO_INSERT in two places - line 167 and 226.

To have a list as wide as possible, the calls' parameters have to be modified - a new screen and list size has to be provided and buttons moved (to make the room for the bigger list). This can be achieved by modifying following parameters:

HEADER - here a new maximum size for the screen has to be provided
FLDS_TO_CONT - here a new position for the Maintenance View list buttons has to be provided
- For NAME = VIM_POSI_PUSH
- For NAME = VIM_POSITION_INFO
CONT - last but not least, the new size for the table with the records
To be precise, HEIGHT = 198 - LINE.

After these changes are done, the new screen will be generated with a maximum size allowed and with resizing options checked (these are checked by default) - which makes the screen to be sized down in case of a lower resolution.

Summary

Thanks to this modification, a list screen of all Maintenance Views will use as much space as possible, making it easier to view and/or maintain configuration. The difference between the standard size and the modified size is clearly visible.

Standard:

Modified:

Analyzing Unexpected Runtime Behavior of CDS Annotations Values in Your ABAP Data Model

2024-07-03T10:46:47.238000+02:00

Picture this: you've just added a CDS annotation to a data definition. But, the annotation's value isn't showing up as expected in your ABAP data model (ADM). What's your next move to analyze the runtime behavior? Are you familiar with the relevant CDS tools in ABAP development tools for Eclipse (ADT) to figure this out? If not, sit back, relax, and enjoy this blog post.

Note: You can use CDS annotations for the whole CDS object, elements, and parameters to add domain-specific metadata, like text labels, object names, layer information, switch status, and so on, to your ADM.

For more information, see Annotations in ABAP CDS

Active Annotations View

The Active Annotations view displays the whole structure of a data definition with its elements and parameters in a tree. In addition, you can see here the according active values, texts, and the names of the contributing original resources column-wise.

This means, you get here a clear overview with all the relevant information that relates to your data definition with only a few clicks. That’s great, isn’t?

For more information, see Active Annotations View

Activation and Evaluation of CDS Annotations

When activating a CDS object, the values of the containing annotations will be saved in internal system tables. From here, they can be accessed and used for evaluation.

The evaluation of annotations is performed in a predefined order. This means, if there is a value for the same element several times provided in your ADM, the system will consider the relevant values in accordance. If the value is …

handled by a metadata extension, it will be on top. This means, no other value of this element will then be considered.
a direct annotation that is defined and handled in the actual data definition, this value will be considered when no value of the same element is provided by a metadata extension.
a indirect annotation that is selected, derived, or inherited from another data sources, this value will be considered when the cases from step 1 and 2 don’t apply.

For more information, see

Sample

Here, the Active Annotation view has been opened for the CDS_View_Test_2 data definition. The structure with the annotations that are defined for the whole CDS object is followed by the entity annotations that are effective for the respective elements. In addition to the values, the additional metadata, such as the annotation value, label text, and so on, is displayed column-wise.

The active values are displayed in accordance to the order how the CDS annotations are evaluated. See above. Beside visualizing the ADM, you can also navigate, for example, to the origin data source from the displayed annotation value. To do this, just double-click the relevant name.

Note that you can switch between the flat and structured representation. For example, if you work with a huge ADM and you prefer a flat structure, don’t worry and just click the icon with the 3 dots in the integrated toolbar and choose Flat representation.

Use

You can trigger this view for …

the complete data definition: Select the data definition in the Project Explorer or select the name of the CDS entity.
the complete CDS entity: Select the name of the CDS entity in the ABAP CDS source code.
a specific element or parameter: Select the relevant element/parameter in the ABAP CDS source code.

After your selection, choose Open With… > Active Annotation from the context menu.

Annotation Propagation View

The Annotation Propagation view visualizes from which CDS view, ABAP Dictionary object, or metadata extension the annotation values have been merged as well as which values have not been considered in a tabular way. This means, you get a list with all relating data sources and their metadata per row.

If there is a value for the annotation from a data source, this value will then be evaluated as I have described it above. The value which will be considered is coloured black otherwise in grey.

For more information, see

Sample

Here, the Annotation Propagation view has been triggered for field_4 that is used in the CDS_View_Test_2 data definition. The respective annotation value for this field is merged from the metadata extension CUSTOMER_EXTENSION_2 and the data definition CDS_VIEW_TEST_1. The values from higher levels are marked in black. This means, these values are active. The value from the metadata extension PARTNER_EXTENSION_2 is marked in grey. This means, this value is inactive and won’t be considered.

You can easily adapt your selection and update the content to be displayed. In the Annotations For input field choose Browse… and add the relevant new basis.

In addition, you can also navigate to the displayed data source. To do this, just double-click the name of the relevant object.

Use

You open this view on the same way how the Active Annotation view. Open the context menu from the relevant position and choose Open With… > Annotation Propagation from the context menu. The Annotation Propagation view will then be opened in a new view below the editor.

Data Preview

I'm sure you're already familiar with the data preview. It shows you the values of the data records that are retrieved from your ADM on a tabular way. This helps you to get a clear overview about the values that are selected from your CDS view quickly.

For more information, see Data Preview

Sample

Here, the data preview has been opened for the R_TRAVEL_D data definition. It shows the data and values that are retrieved with your ADM.

Use

You have the following possibilities to open the data preview from the context menu.

The Data Preview… option with the 3 dots allows you to limit the number of elements to be displayed.

This limits the number of columns and makes it more reader-friendly for you. You can change filter whenever you need it. Just select or deselect the relevant entries.

In addition, you can trigger filtering also from the integrated toolbar:

In a new tab, the filter field is then opened.

Here, you can start typing your search string.

Note that you might need to consider lower and upper case. To bring your search input into the relevant style, you can use the following shortcuts:

Shortcut	Description
Ctrl+Shift+X	Converting entries in the input field to upper case
Ctrl+Shift+Y	Converting entries in the input field to lower case

Features

When selecting an entry in the data preview, you have the following possibilities to trigger certain functionalities from the context menu:

From the context menu, you can choose:

Quick Filter On
Distinct Values For
Follow Association
Copy / Copy All Rows As

Quick Filter On

You can filter the data preview for a specific value very easily. Select the relevant value and choose Quick Filter On from the context menu.

Then, only the lines with the respective values are displayed.

Distinct Values For

Choose this function if you want to find the duplicate values that are merged by your CDS view. Click the relevant value in the table and choose Distinct Values For in the context menu.

You will then get an overview how often a value is duplicate in your ADM.

This list helps you investigate duplicates in your ADM. In addition, you can use it to estimate if the ADM selects the expected data.

Following Associations

In the data preview, you can toggle through the association order of a value. This means, you can check from which data source the associated value is merged from. ADT will bring you to your target.

After selection, the list of associations is displayed in a dialog.

From here you can navigate to the relevant association. If you want to get back to the original data preview, use the breadcrumb on top of the Data Preview view.

Copy Features

Copy

You can copy the content of a cell, row, or the selected column.

Copy All Rows As

You can copy and export all displayed row as ABAP value statement or CSV file.

Feedback & Discussion

Was this content helpful for you? Do you have further question? Just leave a comment below and let’s have a discussion! I look forward to hearing from you!

A Comprehensive Guide to Using OLE Objects in SAP ABAP

2024-07-03T14:37:38.532000+02:00

In this blog, we’ll explore how to use OLE objects in SAP ABAP to automate tasks in Microsoft Word. We will cover the basics, including how to create an OLE object, manipulate data, and handle errors.

Introduction to OLE in SAP ABAP

OLE Automation in ABAP enables you to control Microsoft Office applications. You can create documents, fill in data, format cells, and even run macros—all from within your ABAP programs. This is particularly useful for generating reports, exporting data, and performing complex calculations.

Prerequisites

Before you begin, ensure that:

You have access to a Microsoft Office installation on the machine running the SAP GUI.

You have basic knowledge of ABAP programming.

Creating an OLE Object

To start using OLE in ABAP, you first need to create an OLE object. The CREATE OBJECT statement in ABAP is used for this purpose.

This code will extract the data from database table ‘mara’ and populate into the word file using the concept of OLE .

REPORT ZTEST_BLOGYS.
PARAMETERS: p_file  TYPE localfile DEFAULT 'C:\Users\Yeshica.Sharma\Downloads\p0.docx'.   “we are declaring file pathwhere we  need to store word file. 
INCLUDE ole2incl.

We are declaring data and creating ole object

DATA:        “we are declaring data for ole object
  ***      OLE Object
  gs_word           TYPE    ole2_object, "Word Object
  gs_documents      TYPE ole2_object, "List of documents
  gs_document       TYPE ole2_object, "Current / Active document
  gs_selection      TYPE ole2_object, "Current Cursor Selection
  gs_actdoc         TYPE ole2_object , "Active document
  gs_font           TYPE ole2_object , "Font
  gs_parformat      TYPE ole2_object , "Paragraph format
  gs_tables         TYPE ole2_object , "Tables
  gs_table          TYPE ole2_object,
  gs_range          TYPE ole2_object,
  gs_cell           TYPE ole2_object,
  gs_border         TYPE ole2_object,
  gs_interior       TYPE ole2_object,
  gs_application    TYPE ole2_object, "Application
  gv_pos(5)         TYPE n , "Position information for table
  wf_lines          TYPE i,
  wf_counter        TYPE i,
  lv_date           TYPE char15,
  lv_data           TYPE string,
  lv_copyrightdata  TYPE string.
  "Create word object
   CREATE OBJECT gs_word 'WORD.APPLICATION'.
* Setting object's visibility property
  SET PROPERTY OF gs_word 'Visible' = 1.
*  Opening a new document
  CALL METHOD OF gs_word 'Documents' = gs_documents.
  CALL METHOD OF gs_documents 'Add' = gs_document.
*  Activating the sheet
  CALL METHOD OF gs_document 'Activate'.
* Getting active document handle
  GET PROPERTY OF gs_word 'ActiveDocument' = gs_actdoc.
*  Getting applications handle
  GET PROPERTY OF gs_actdoc 'Application' = gs_application.
* Getting handle for the selection which is here the character at the cursor position
  GET PROPERTY OF gs_application 'Selection' = gs_selection.
  GET PROPERTY OF gs_selection 'Font' = gs_font.
  GET PROPERTY OF gs_selection 'ParagraphFormat' = gs_parformat.

We are declaring data and getting a data from Database table Mara

Types : Begin of ty_mara,
        Matnr type mara-matnr,
        ersda type mara-ersda,
        ernam type mara-ernam,
        end of ty_mara.
data : it_mara type table of mara,
       wa_mara type mara.
select matnr ersda ernam from mara into corresponding fields of table it_mara UP TO 5 ROWS.

We are creating table and populating data into a word file

CALL METHOD OF gs_selection 'TypeText'
    EXPORTING
      #1 = 'DATA OF MARA TABLE'.
      GET PROPERTY OF gs_actdoc 'Tables' = gs_tables.
      GET PROPERTY OF gs_selection 'Range' = gs_range.
      DESCRIBE TABLE it_mara LINES wf_lines.
      wf_lines = wf_lines + 1.
      IF sy-subrc NE 0. 
      ENDIF.
      CALL METHOD OF gs_tables 'Add' = gs_table
              EXPORTING #1 = gs_range
                        #2 = wf_lines
                        #3 = '3'. "Columns
      GET PROPERTY OF gs_table 'Borders' = gs_border.
      SET PROPERTY OF gs_border 'Enable' = '1'.
      IF sy-subrc NE 0. 
      ENDIF.
      CALL METHOD OF gs_table 'Cell' = gs_cell
      EXPORTING #1 = '1'
      #2 = '1'.
*  *setting the bg color
      CALL METHOD OF gs_cell 'Shading' = gs_interior.
      SET PROPERTY OF gs_interior 'BackgroundPatternColor' = -570376193.
      GET PROPERTY OF gs_cell 'Range' = gs_range.
      SET PROPERTY OF gs_range 'Text' = 'matnr'.
      CALL METHOD OF gs_range 'Font' = gs_font.
      SET PROPERTY OF gs_font 'Bold' = '1'. " Make the text bold
      CALL METHOD OF gs_range 'SetFont' = gs_font.
      IF sy-subrc NE 0. ENDIF.
************************* Col 2
      CALL METHOD OF gs_table 'Cell' = gs_cell
        EXPORTING #1 = '1'
        #2 = '2'.
*  *setting the bg color
      CALL METHOD OF gs_cell 'Shading' = gs_interior.
      SET PROPERTY OF gs_interior 'BackgroundPatternColor' = -570376193.
      GET PROPERTY OF gs_cell 'Range' = gs_range.
      SET PROPERTY OF gs_range 'Text' = 'ersda'.
      CALL METHOD OF gs_range 'Font' = gs_font.
      SET PROPERTY OF gs_font 'Bold' = '1'. " Make the text bold
      CALL METHOD OF gs_range 'SetFont' = gs_font.
      IF sy-subrc NE 0. ENDIF.
**********************  Col 3
      CALL METHOD OF gs_table 'Cell' = gs_cell
        EXPORTING #1 = '1'
        #2 = '3'.
*  *setting the bg color
      CALL METHOD OF gs_cell 'Shading' = gs_interior.
      SET PROPERTY OF gs_interior 'BackgroundPatternColor' = -570376193.
      GET PROPERTY OF gs_cell 'Range' = gs_range.
      SET PROPERTY OF gs_range 'Text' = 'ernam'.
      CALL METHOD OF gs_range 'Font' = gs_font.
      SET PROPERTY OF gs_font 'Bold' = '1'. " Make the text bold
      CALL METHOD OF gs_range 'SetFont' = gs_font.
      IF sy-subrc NE 0. 
      ENDIF.
      wf_counter = 1.
      LOOP AT it_mara INTO wa_mara.
      wf_counter = wf_counter + 1.
       CALL METHOD OF gs_table 'Cell' = gs_cell
         EXPORTING #1 = wf_counter
         #2 = '1'.
        GET PROPERTY OF gs_cell 'Range' = gs_range.
        SET PROPERTY OF gs_range 'Text' = wa_mara-matnr.
        IF sy-subrc NE 0.
        ENDIF.
       CALL METHOD OF gs_table 'Cell' = gs_cell
          EXPORTING #1 = wf_counter
          #2 = '2'.
        GET PROPERTY OF gs_cell 'Range' = gs_range.
        SET PROPERTY OF gs_range 'Text' = wa_mara-ersda.
        IF sy-subrc NE 0.
        ENDIF.
       CALL METHOD OF gs_table 'Cell' = gs_cell
          EXPORTING #1 = wf_counter
          #2 = '3'.
        GET PROPERTY OF gs_cell 'Range' = gs_range.
        SET PROPERTY OF gs_range 'Text' = wa_mara-ernam.
        IF sy-subrc NE 0.
        ENDIF.
      ENDLOOP.
*--Advancing the cursor to the end of the table
      GET PROPERTY OF gs_table 'Range' = gs_range .
      GET PROPERTY OF gs_range 'End' = gv_pos .
      SET PROPERTY OF gs_range 'Start' = gv_pos .
      CALL METHOD OF gs_range 'Select' .
      DO 2 TIMES.
        CALL METHOD OF gs_selection 'TypeParagraph' .
      ENDDO.
      IF sy-subrc NE 0.
      ENDIF.

Output is like below -

Conclusion
Integrating OLE objects in SAP ABAP provides a seamless way to leverage the powerful functionalities of Microsoft Office applications directly within your SAP environment. By automating tasks in Excel, Word, or PowerPoint, you can enhance productivity, streamline workflows, and create dynamic reports. Understanding how to create and manipulate OLE objects in ABAP opens up a myriad of possibilities for SAP developers, allowing for the creation of sophisticated solutions that integrate the best of SAP and Microsoft Office capabilities. With the steps and examples provided, you are now equipped to start incorporating OLE automation into your ABAP programs, making your SAP applications more versatile and efficient.

Hope this may helpful.

ABAP CDS Select from dynamic data source

2024-07-08T14:20:49.192000+02:00

Hello friends,

I faced a little problem while reporting in Fund Management (FM) module as the tables are generated automatically while creating derivation rules with dynamic names and differs by system /client.

The rule entries are stored in the generated table "FMFMOAXXXYYYZZZZ", where XYZ symbols means as follows:

XXX is the system specification (e.g., DE1 or QE1)
YYY is the client number (e.g., 120 or 200)

ZZZZ is the number of the derivation rule (which you should have as per your table 31, 51, 64, or 61)

To be able to move my report / solution I had to selecting from dynamic source which is not supported in CDS!

After investing some time I came to try it using AMDP with table function

Now let's explain it as simple as possible.

*Step 1 create a table function *

@EndUserText.label: 'demo table function' 
define table function zcds_amdp_demo_tf with parameters @Environment.systemField:#CLIENT clnt5 : abap.clnt, derivation : char4 
returns { 
MANDT : mandt ; 
SOUR1_FROM : ps_posid ;
SOUR1_TO : ps_posid ;
VALID_FROM : abaintab ;
TARGET1 : fistl;
DELETE_FLG : abadrdelflag;
ADDED_BY : abadrerfasser;
ADDED_ON : erdat; 

} 
implemented by method zcl_amdp_demo=>get_data;

*Step 2 Create the class zcl_amdp_demo*

CLASS zcl_amdp_demo DEFINITION PUBLIC FINAL CREATE PUBLIC.
PUBLIC SECTION.
INTERFACES: if_amdp_marker_hdb, if_oo_adt_classrun.

CLASS-METHODS get_data FOR TABLE FUNCTION zcds_amdp_demo_tf.
PROTECTED SECTION.
PRIVATE SECTION.
ENDCLASS.

CLASS zcl_amdp_demo IMPLEMENTATION. 
  METHOD get_data BY DATABASE FUNCTION FOR HDB LANGUAGE SQLSCRIPT OPTIONS READ-ONLY USING tadir.
    declare lv_fm_tab string; 
    declare tablename string; 
    declare clientnumber string; 
    declare systemid string; 
    declare deriv string;
*must be the same data types as consuming cds also in same order 
declare it_fm_tab table ( 
  MANDT nvarchar(3), 
  SOUR1_FROM nvarchar(24), 
  SOUR1_TO nvarchar(24), 
  VALID_FROM nvarchar(10), 
  TARGET1 nvarchar(16), 
  DELETE_FLG nvarchar(1), 
  ADDED_BY nvarchar(12),
  added_on nvarchar(10) ); 
  
* fmfmoaxxxyyyzzzz 
*fields from parameters 
clientnumber = clnt5; 
select srcsystem into systemid from tadir where pgmid = 'HEAD' and object = 'SYST';

*'COST' => Cost Element = Commitment Item 
*'WBSE' => wbs Element = Funds Center

  if derivation = 'COST' then
    if systemid = 'DS1' then deriv = '0051'; end if; 
    if systemid = 'QS1' then deriv = '0062'; end if; 
    if systemid = 'PS1' then deriv = '0051'; end if; 
  else
    if systemid = 'DS1' then deriv = '0052'; end if;
    if systemid = 'QS1' then deriv = '0064'; end if;
    if systemid = 'PS1' then deriv = '0041'; end if; 
  end if; 
  
  tablename = 'FMFMOA' || systemid || clientnumber || deriv; 
  
  EXECUTE immediate 'select MANDT, SOUR1_FROM, SOUR1_TO, VALID_FROM, TARGET1, DELETE_FLG, ADDED_BY, ADDED_ON from ' || tablename into it_fm_tab ;
  
  RETURN SELECT * FROM :it_fm_tab; ENDMETHOD.
ENDCLASS.

*Step 3 and final Create a sonsumable CDS view*

@AbapCatalog.sqlViewName: 'ZCDS_AMDP_DEMO_V' 
@AbapCatalog.compiler.compareFilter: true 
@AbapCatalog.preserveKey: true 
@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'CDS that consuming the TF' 
define view zcds_amdp_demo as select from zcds_amdp_demo_tf (clnt5 : $session.client, derivation : 'COST' ) 
//COST => Cost Element = Commitment Item 
//WBSE =>WBS Element = Funds Center 
{ 
* 
}

Output:

A Closer look: if you change the parameter from 'COST' to 'WBSE' the return changes which makes it dynamic selection now 🙂 .. congratulations!

Please feel free to comment any observations, enhancements or recommendations.

Regards,
Abdelrahman Zaki

Switch Framework-SAP

2024-07-10T17:23:37.182000+02:00

The main purpose of the Switch Framework is to simplify an ABAP-based system landscape by adopting one or more industry solutions in a standard system. The Switch Framework allows you to externally control the visibility of repository objects or their components by means of switches.

A switch is a repository object that controls the visibility of other repository objects.
A business function is a self-contained function from a business perspective and consists of a set of switches
A business function set corresponds to an industry solution and is a group of business functions

Switch Framework Components

It’s possible to have child-parent relationships between the main components of the Switch Framework. Not only can you assign switches to business functions and business functions to business function sets, you also can assign business function sets to business functions and switches to business functions. Business function sets can be nested and can have superordinate and subordinate business function sets.

Switch

A switch is the technical level of switching objects on and off. You use a switch to control the behaviour of the objects assigned to it.

Here we discuss about the creation of switches. Starting with Tcode SFW1, where we will create a new switch. In the ‘Package’ tab, we can add our package name. Here I have added my package ‘ZSWF_NEW’, where I will be saving the enhancements which I add later. Save and activate the switch.

Business Function

Next, we need to create a Business Function via the Tcode SFW2.

A Business Function is a a group/set of switches.

A business function is a building block of a business function set.

From a business perspective, it represents a self-contained function that you can switch on. From a technical point of view, it is a set of switches that assign repository objects to the business function. Business functions are switched on at a system level.

A switch controls the visibility or run time behavior of different repository objects assigned to it. A switch can have 3 states as on, off & standby.

ON- The objects behave like non switchable objects.
OFF- The system behaves as these objects do not exists.
STAND BY- All dictionary objects and all static code enhancements like enhancement point point & section (STATIC) are switched on but other objects are switched off.

When you switch on a business function, all switches assigned to it are switched to ON or STANDBY, respectively, depending on the definition of the business function.

The business functions can be reversible and non-reversible. Only reversible business functions can be switched off.

The following types of business functions are available:

Industry Business Function: always needs a business function set to be attached to
Enterprise Business Function: independent of business function sets
Enterprise Add-Ons: can no longer be created. Semantically they are the same as Enterprise Business Functions but are based on another technique.

I have created a business function with Type G which is an enterprise business function.

In the Business function, I have added the switch which we have created in the previous step. See the image below.

In case if you have created an Industry Business Function, it's always needing a business function set to be attached to. Those who are following with Enterprise Business Function (as followed above) can avoid this step of creating Business function set and can continue with SFW5 to switch on business functions.

Business Function Set

You use a business function set to bundle business functions into your system.

Next, we need to create a Business Function Set via the Tcode SFW3.

Business Function set is a group/collection of business functions.

Business Function Set is the top component of the Switch Framework and represents an industry solution that you tailor from existing solutions in the SAP system.

Add your business function to business function tab then, save and activate.

Now, goto transaction SFW5 and expand the ENTERPRISE_BUSINESS_FUNCTIONS and below

We can see our business function, for activating switch we need to click the click box and do activate

In this switch package we added append structure in custom table, once switch is activated, we can go and see the that append structure, it will show now switch on we can see in below image.

Conclusion:

The Switch is reversable, if we want to do deactivate the switch, we need to do reversable.

SAP OABAP Programming using Test-seam and Test-injection

2024-07-10T17:29:17.885000+02:00

I am happy to share my very first blog post on SAP OABAP Programming using Test-seam and Test-injection. In this blog post you will learn how to use a Test-seam and Test-injection.

Test-seam and Test-injection

Test-seam

Seam inserted between the statements seam and end-seam in production source code and which can be replaced by an injection when module tests are run.

What is ABAP Test Seam?

Scope of use : Writing test cases Test seam is an easy way to replace or extend source code in the production part of your program.

Replacement level

In method code

Test Injection life cycle

Replacement works until the end of the test method that defines the injection

Features of Test Seam

Test seam is ignored in production use of the program

A program can contain multiple test seams

Multiple test injection can be defines for a single test seam

Test seam is available for all executable units of the main program including tests including local classes and subroutines

Unit tests can do test injection when executing test methods or setup methods

If injections are repeated in the same test seam the last injection is the active injection

Limitation of Test seam

Injections can only be created in test classes defined in the test included

Scenarios used by test seam

Authorization checks

Reading persistent data

Modifying persistent data

Creating test doubles

Test seam

Injection

TEST-SEAM authorization seam

AUTHORITY-CHECK OBJECT ‘S_CTS_ADMI’

ID ‘CTS_ADMFCT’

FIELD ‘TABL’.

END-TEST-SEAM

IF sy-subrc = 0

Is_authorized = abap_true.

ENDIF.

TEST-INJECTION

authorization

seam

Sy-subrc = 0.

END-TEST-INJECTION

1. Created a class it’s having method called fetch data

2. We need to create the local test class.

3. While providing the session breakpoints in the test class we can debug the ABAP unit class

4. If we click on coverage it will navigate to the debugging screen

5.In the ev_mara there no data will be present if we execute the code line by line

6.It will go to the development code

7.If you executed the code in the test-seam it will go to the test-injection

8.There am mocking the data for the table by that ev_mara parameters will get the data

9.Now the select query is successful so it’s entering sy-subrc condition

10.Once the code is done we need to check the coverage .

Refer the code Below

Refer the code Below 

  METHOD fetch_data. 
     TEST-SEAM mara. 
       SELECT matnr mtart FROM mara INTO CORRESPONDING FIELDS OF TABLE ev_mara WHERE matnr = iv_matnr. 
     END-TEST-SEAM. 
     IF sy-subrc = 0. 
     MESSAGE 'Record found' type 'S'. 
     ELSE. 
        MESSAGE 'Record not found' type 'E'. 
     ENDIF. 
 
  ENDMETHOD. 

*"* use this source file for your ABAP unit test classes 
CLASS lcl_test DEFINITION FOR TESTING RISK LEVEL HARMLESS DURATION SHORT. 
   PUBLIC SECTION. 
     METHODS : _fetch_data FOR TESTING. 
   PRIVATE SECTION. 
     METHODS : setup , 
       teardown. 
     DATA : lo_fcut TYPE REF TO zsh_cl_test_seam1. 
 
ENDCLASS. 
CLASS lcl_test IMPLEMENTATION. 
   METHOD setup. 
     CREATE OBJECT lo_fcut. 
   ENDMETHOD. 
   METHOD teardown. 
     FREE : lo_fcut. 
   ENDMETHOD. 
   METHOD _fetch_data. 
     DATA : ev_mara  TYPE zsh_cl_test_seam1=>tt_mara, 
            lv_matnr TYPE matnr. 
     lv_matnr = 'CM-FL-V00'. 
     "=======Mocking the data using test injection. 
     TEST-INJECTION mara. 
       ev_mara = VALUE #( ( matnr = 'CM-FL-V00' mtart = 'KMAT' ) 
                           ( matnr = 'CM-FL-V01' mtart = 'KMAT' ) 
                           ( matnr = 'CM-MLFL-KM-VXX' mtart = 'KMAT' ) ). 
 
    END-TEST-INJECTION. 
     lo_fcut->fetch_data( 
       EXPORTING 
         iv_matnr =    lv_matnr              " Material Number 
       IMPORTING 
         ev_mara  =  ev_mara 
     ). 
     cl_abap_unit_assert=>assert_equals( 
       EXPORTING 
         act                  =   ev_mara                                     " Data object with current value 
         exp                  =   ev_mara                              " Data object with expected type 
     ). 
   ENDMETHOD. 
ENDCLASS.

We have a standard class for test seam and injection

CL_AU_SAMPLE_TEST_SEAMS

Watch the Replays of Our Exclusive SAP S/4HANA Cloud Public Edition 2408 Early Release Series

2024-07-12T17:15:51.644000+02:00

With SAP S/4HANA Cloud Public Edition, we offer a fully-fledged cloud ERP that optimizes processes and helps your business to run smoothly. We as the Cloud ERP PSCC organization strive to enable our valued customers and partners to take full advantage of the benefits our solution brings for the intelligent, sustainable enterprise.

Therefore, we offer a variety of enablement assets to explain the features and functions of each new release and make sure that you get the maximum value out of your investment.

The SAP S/4HANA Cloud Public Edition Early Release Series is a series of compelling live product expert sessions that takes place twice a year and is designed by product experts for product experts to give customers, partners, and colleagues a special insider’s preview into the highlights for selected lines of business and industries, 1-2 weeks before the actual release. In a span of multiple days, we give you the opportunity to see the latest demos, ask your questions, and get answers straight from the product experts before everyone else.

From July 8 to July 12, we hosted a series of 20 compelling live sessions to highlight the exciting innovations shipped with the SAP S/4HANA Cloud Public Edition 2408 release. Missed the live sessions? We've got you covered! Take advantage of the entire series or pick and choose the sessions most relevant to you.

Don't miss this chance and watch them on demand – anywhere, anytime.

Artificial Intelligence and Technologies	Watch here
Two-Tier ERP	Watch here
Manufacturing	Watch here
SAP Activate, SAP Cloud ALM, Test Automation Tool	Watch here
Enterprise Portfolio and Project Management	Watch here
Cross Technology Topics	Watch here
Professional Services	Watch here
Product Compliance	Watch here
Sourcing and Procurement	Watch here
Asset Management	Watch here
SAP User Experience	Watch here
Public Sector Management	Watch here
Service	Watch here
Extensibility	Watch here
Sales	Watch here
Solution Orders and Subscription Billing	Watch here
Finance	Watch here
Supply Chain Management	Watch here
Governance, Risk, and Compliance	Watch here
Environment, Health, and Safety	Watch here

Find the recordings of previous live sessions here, here, and here.

How to Sign Up for the SAP Enterprise Support Edition as a Customer/Partner

In order to watch the recordings, you will need to have an active SAP Learning Hub license with at least the SAP Enterprise Support Edition. Find out how to register for the SAP Enterprise Support edition in case you don’t already have access to any of the editions yet:

Navigate to the sign up page
Click the Sign up button. Authenticate yourself with your s-user ID and password. Upon first access, the system will check your eligibility, create a new SAP Learning Hub user, and populate your learning catalog respectively. Within two hours, you will then receive a registration confirmation via e-mail.
After you have received the confirmation e-mail, the registration process is complete.

Partners can access the recordings through an SAP Partner Edge Edition.

How to Sign Up for the Internal Edition as an SAP Employee

In order to watch the recordings, you will need to have an SAP Learning Hub license. In case you have no edition assigned to your profile, please register here for the Internal Edition which is free of charge.

Make sure to be logged onto the SAP Learning Hub before opening the URL. In case the link doesn't open, copy and paste it into your browser. If you face any other issues with your login, please contact the help center.

Follow the SAP S/4HANA Cloud Public Edition tag and the PSCC_Enablement tag to stay up to date with the latest blog posts.

🎙️ Inside SAP S/4HANA Cloud

There is no customer success without project success and product success! Leverage the unique knowledge and expertise of SAP S/4HANA Cloud experts, partners, and customers, sharing their SAP S/4HANA Cloud implementation project best practices and lessons learned – anywhere, anytime. In this podcast, we give you all ingredients to get to the next level and make your SAP S/4HANA Cloud project a success. Subscribe now and benefit from the shared knowledge!

💻openSAP Microlearnings for SAP S/4HANA Cloud

Our openSAP microlearnings for SAP S/4HANA Cloud offer an exciting new learning opportunity. What began with a small batch of 20 videos, has now become a channel with more than 50 microlearnings that have generated over 20,000 views. Today, we cover multiple lines of business such as finance, manufacturing, and supply chain management, and key technology topics like Master Data Management, extensibility, SAP User Experience, and upgrade management. We are continuously adding new microlearnings to our channel, so make sure you check them out.

🗣️ Your Voice Matters

You want to learn more and actively engage with SAP subject matter experts on SAP S/4HANA Cloud topics? We have just the right place for you! Join our interactive community where we bring together customers, partners, and SAP experts with a clear mission: To engage with one another about best practices and product solutions. We invite you to explore the ‘one-stop shop’ as the central place for all resources, tools, content questions, answers and to connect with experts who will guide you through your journey to the intelligent, sustainable enterprise.

🔎Find All of Our Assets

SAP S/4HANA Cloud is the foundation of the intelligent, sustainable enterprise and is an innovative, robust, and scalable ERP. We at Cloud ERP Product Success and Cloud Co-Innovation offer a service as versatile as our product itself. Check out the numerous offerings our team has created for you below:

🎯Where to Find More Information:

Explore the ready-to-run cloud ERP here: https://www.sap.com/products/erp/s4hana.html
Watch our SAP S/4HANA Cloud product update videos on YouTube: https://www.youtube.com/playlist?list=PLWV533hWWvDnnyN2j-CcUheNN-GaNCb3H
Check out our digital enablement wheel here: https://chart-bdmaicr0au.dispatcher.eu2.hana.ondemand.com/index.html?hc_reset
Listen to our podcast here: https://podcast.opensap.info/inside-sap/
Watch our openSAP microlearnings to learn about SAP S/4HANA Cloud topics at your own pace here: https://microlearning.opensap.com/
Find best practices on SAP S/4HANA Cloud Public Edition here: https://me.sap.com/processnavigator/SolS/EARL_SolS-013/latest?region=DE
Check out what’s new here: https://help.sap.com/doc/ce01d82756b947a1a043a5d5a3204226
Find help here: https://help.sap.com/docs/SAP_S4HANA_CLOUD
Read the feature scope description here: https://help.sap.com/doc/7c9e0bbbd1664c2581b2038a1c7ae4b3

Grounding is All You Need

2024-07-13T16:10:50.558000+02:00

Hey everyone,

Following my last blog post (SAPPHIRE 2024 – My impressions and vision on what is ahead for us), I want to dive into something crucial that SAP needs to address ASAP: Groundings. Let me explain why this is so important.

What Are Groundings?

In the world of Generative AI (GenAI), one of the key building blocks is Groundings, also known as knowledge bases. Groundings enable a technique called RAG (Retrieval Augmented Generation) to expand the knowledge of a Large Language Model (LLM). Here’s why this matters:

LLM Data Cutoff: LLMs have a cutoff date for the data they can access. They know a lot up to a certain date, but not beyond.
Limited Knowledge on Private Data: LLMs might lack information on personal or company-specific data.
Specific Application Data: Sometimes, you need to add very specific application data that LLMs don’t know.

With RAG, we query vector databases to pre-select semantically related information and pass it to the LLM for additional context. This process is hugely beneficial.

The Need for SAP to Build Groundings

While we’re all working on building our own groundings, there are some that SAP should create and publish. Here are the most pressing ones I can think of:

HELP.SAP.COM: Groundings on help.sap would allow us to create chatbots that can easily answer user queries. This is likely a foundation grounding of Joule, but we all need this. Handling different versions and products is a challenge, but it’s workable. Groundings should be created by product/version.
SAP Training Documentation: This is more complex due to the variety of data types, but incredibly valuable. It extends far beyond what HELP.SAP covers.
ABAP (or Other Technical) Documentation: While SAP has mentioned working on a fine-tuned LLM version, a grounding with numerous referenceable examples would greatly improve quality. Current LLM-generated ABAP examples often display questionable examples.
SAP API Documentation: Detailed explanations on the function and usage of all SAP APIs would be an incredible addition for functional, ABAP, and integration developers. "Is there an API to perform X?" "How do I call this particular API?"
S/4 Data Model: Though more complex to structure, a grounding with all SAP tables, their descriptions, and relations to supporting tables would be beneficial. Utilizing the CDS views repository could be a starting point. "How do I determine delivery status for sales order items?"
COMMUNITY.SAP.COM: There’s a wealth of great content in blogs and forum conversations that could be turned into groundings.
SAP Support Tickets: While sensitive, anonymized support tickets could be made available to customers and partners, significantly reducing support costs across the ecosystem. I’d be willing to pay for that.

How SAP Can Make Groundings Available

SAP could build and offer these groundings in several ways:

For Free: Some of it could be offered for free. 🙂
GenAI Hub: Groundings could be integrated into the GenAI Hub, increasing the platform’s value.
Licensed Access: Groundings could be licensed and charged based on access, allowing consumption anywhere.

Conclusion

These are just a few examples of the groundings SAP could develop to enhance our tools and workflows. It’s time for SAP to step up and help us all achieve more with GenAI.

Tchau for now!

Leo

Innovations Highlights from SAP Business Technology Platform - Sapphire 2024

2024-07-17T10:55:19.306000+02:00

Sapphire is always a highlight. But this year it was a special Sapphire. With this year´s event theme "Bring Out Your Best" our latest business AI innovations, products, and partnerships were highlighted. Take a look at this blog post where I want to focus on the most important announcements of SAP BTP at Sapphire 2024 (also non-AI related). In addition let´s explore innovation highlights coming up in the future. Enjoy reading on.

Clean Core Strategy with New SAP Build and ABAP Cloud Features

Following a clean core strategy means keeping your systems as unmodified as possible and creating your custom code in a way that does not effect upgrades and adoption of the latest innovations. But there is still the need to tailor your systems to your own businesses. To achieve this, we recommend that you go for side-by-side extensibility scenarios with SAP BTP, meaning that you build your own extensions to SAP systems on SAP BTP, whenever possible. SAP BTP offers three main options for this scenario: SAP Build low-code solutions, SAP Build Code and SAP BTP ABAP Environment.

If we look at ABAP, the first highlight is the Joule´s ABAP Developer capabilities, which will contain multiple features all tailored to increase developer efficiency. It will be the GitHub Copilot for the ABAP world embedded directly into the ABAP Development Tools in Eclipse (ADT). You will receive functionality embedded into wizards and an integrated chat. Planned GenAI features are explain ABAP code and CDS code, test and test data generation for ABAP and CDS, ABAP code completion, and many more.

To simplify this process, we are building a way to access SAP Build directly from S/4HANA. Providing the ability to access SAP Build directly and with context from SAP S/4HANA, your development teams and their business stakeholders will be able to create new processes and process extensions much faster and more convenient than in the past.

Guided experiences in SAP Build Work Zone

In addition the Guided experiences in SAP Build Work Zone let developers create step-by-step line-of-business workflows. This simplifies complex business processes through automation without custom code. With the Guided experiences, you can empower your workforce with seamless digital experiences tailored to their needs, boosting user satisfaction, engagement, and retention. You can automate tasks and streamline processes, allowing employees to focus on high-impact work.

Accelerate enterprise automation with AI

We are also enriching our Process Automation offering with Joule. Our GenAI-based copilot will help you to simply specify in natural language what kind of workflow or automation you would like to have. In addition our tools, with the help of different large language models, will help you either source these artifacts from available content, or they will generate new process and automation content for them using the power of AI.

Accelerate integration with AI

We believe that by embedding AI into SAP Integration Suite, you will be able to shorten project times and integrate applications and systems faster by using AI generated mappings, scripts, and integration flows without even needing to be a high end integration expert. The SAP Integration Suite will improve the quality of integration flows and business processes by helping you identify pre-built content packages or by supporting AI-generated artifacts that fit to your specific requirements. Same as with code or process automation artefacts, you will be able to generate integration artifacts, our so called integration flows, by leveraging generative AI and the Unified Customer Landscape service which provides your specific landscape details as context for the integration.

Anomaly detection with SAP Integration Suite

We are making use of machine-learning based capabilities in SAP Integration Suite to offer API anomaly detection. What this means is that we use Machine Learning to identify issues in your landscapes. Think of a sudden surge or drop in API calls, an increase in latency or an increase in the number of errors detected. We can identify this kind of unusual behavior and actively alert your stuff to these anomalies in API performance. This way, we can help identify and address issues before they escalate, minimizing disruptions and optimizing system performance.

Simplified transition

How do I transition from SAP PI / PO to SAP Integration Suite? We know that many of you relying on PI/PO for the daily business and we want to make sure we safeguard the investments you have made. Therefore we will provide a simplified transition from SAP PO to SAP Integration Suite with features like mass migration, reduction of migration templates, and reduction of JMS queues using a pipeline concept. Also, there is a free assessment and planning services available where we provide customer specific recommendations on how to move your integration to the cloud.

If you want to learn more what´s new for Application Development, Automation and Integration on SAP BTP read the blog post of @thomas_volmering.

Infuse AI in SAP Analytics Cloud

How do we evolve our portfolio in the space of Data and Analytics moving forward? First: We integrate Joule as your GenAI copilot in SAP Analytics Cloud. You can analyze, consume and create story content with Joule moving forward. You also have also the possibility to ask questions and get answers as charts. Or you can generate some scripts to make the story interaction for your end-users richer and more interactive. Remember the just ask feature? This will be integrated with Joule as well. The key thing to understand is that while the just ask feature is providing natural language query capabilities, Joule will be using this feature as well, but provide a more conversational experience in remembering the conversation and the user progress and integrations.

Extended capabilities in SAP Analytics Cloud

One more thing on Data and Analytics, as it touches both the themes of openness and connectivity. Later this year it is planned that SAP Analytics Cloud content will be able to natively be integrated with Microsoft PowerPoint. Using our add-in, you can intuitively connect to an SAP Analytics Cloud tenant and find user-created content to integrate into your presentation. For example stories, in which business users communicate business information using a combination of data and visual elements (like, building a heat map of North America illustrating where a company’s sales are overperforming and underperforming commercial expectations). Or Widgets, which are visual elements used to tell stories (for example, charts, tables, geographical maps, or buttons).

SAP Analytics Cloud will also let you connect to SQL data sources as live data connections. This eliminates the need for direct data replication, resulting in much faster access to real-time data, reduced data storage requirements, more reliable data consistency, improved system performance and lower costs.

More to come...

For me personally it has been a quite impressive and innovative Sapphire 2024. If you want to explore more highlights coming up in 2024 watch the replay of my session "Explore the road map of SAP BTP".

You did not make it in person or virtually? No worries, you still have the chance to watch the replays and especially the Opening Keynote of Christian Klein and Julia White. Explore the SAP Sapphire News Guide 2024 to learn more about the announcements.
Interested in more innovation highlights coming up? Then take a look at our Road Map Explorer. We do have more than 1000 innovation highlights planned for SAP BTP 2024.

Also be informed that this blog and SAP's strategy and possible future developments, products and or platforms directions and functionality are all subject to change and may be changed by SAP at any time for any reason without notice.

Understanding SAP RAP, CAP, Build, Joule, Embedded Analytics: A Simple Guide

2024-07-20T20:17:08.413000+02:00

Introduction

In the rapidly evolving world of SAP, staying updated with the latest technologies can be challenging. Today, we will simplify five key SAP technologies: SAP RAP, SAP CAP, SAP Build, SAP Joule, and SAP Embedded Analytics. Let’s understand what they are, how they differ, and when to use each one.

SAP RAP (Restful ABAP Programming)

Let’s start with SAP RAP. ABAP has been the backbone of SAP for years, and RAP brings a modern approach to it.

What is it?: RAP stands for Restful ABAP Programming. It’s a methodology to develop Fiori apps using ABAP, adhering to modern RESTful principles.
Why use it?: If you are an experienced ABAP developer, RAP makes it easier to develop cloud-ready and service-oriented applications without having to learn a completely new language.
Where to use it?: It’s ideal for those already familiar with ABAP and looking to transition to S/4HANA and cloud environments.

SAP CAP (Cloud Application Programming)

Next, let’s look at SAP CAP. This technology is gaining a lot of attention.

What is it?: CAP, or Cloud Application Programming model, is SAP’s framework for developing cloud-native applications. It combines JavaScript, Node.js, and OData services.
Why use it?: CAP is great for building scalable, flexible, and modern applications on the SAP Cloud Platform. It leverages the best of modern web development technologies.
Where to use it?: Ideal for developers comfortable with modern web technologies and looking to harness the full potential of the cloud.

SAP Build

Now, let’s discuss SAP Build. This tool is for those who might not be expert coders but still want to create powerful applications.

What is it?: SAP Build is a no-code/low-code platform that allows you to design, develop, and deploy applications with minimal coding.
Why use it?: It’s perfect for rapid prototyping and quickly bringing applications to life. SAP Build simplifies the development process significantly.
Where to use it?: Best for business users or developers who need to create applications quickly without deep coding knowledge.

SAP Joule

Let’s move on to SAP Joule. This one is relatively new and focuses on artificial intelligence.

What is it?: SAP Joule is an AI-driven tool designed to bring advanced intelligence to business processes, helping users make smarter decisions.
Why use it?: It integrates AI into your existing SAP landscape, providing insights and automation capabilities that can greatly enhance productivity.
Where to use it?: Ideal for organizations looking to incorporate AI and machine learning into their SAP systems to drive innovation and efficiency.

SAP Embedded Analytics

Finally, we have SAP Embedded Analytics. This tool is all about leveraging data for better insights.

What is it?: Embedded Analytics allows real-time analytics within SAP applications, providing users with immediate insights without needing to switch to separate analytics tools.
Why use it?: It offers real-time data analysis and visualization capabilities, enhancing decision-making processes with up-to-date information.
Where to use it?: Best for organizations that need to embed analytics directly into their business processes to enable data-driven decision-making.

Comparison: RAP vs. CAP vs. Build vs. Joule vs. Embedded Analytics

Ease of Use: SAP Build is the easiest to use, followed by RAP. CAP requires more knowledge of modern development practices. SAP Joule and Embedded Analytics need an understanding of AI and data analytics, respectively.
Flexibility: CAP offers the most flexibility for developing cloud-native applications. RAP is flexible within the ABAP environment, Build is great for quick and simple applications, Joule enhances processes with AI, and Embedded Analytics provides real-time data insights.
Use Case:Use RAP if you are sticking with ABAP and S/4HANA.CAP for new cloud applications. Build for rapid prototyping and business user-driven development. Joule for integrating AI into your business processes. Embedded Analytics for embedding real-time analytics into your operations.

Conclusion

Whether you are an experienced ABAP developer looking to modernize with RAP, a tech enthusiast exploring cloud-native development with CAP, a business user aiming for quick wins with SAP Build, an innovator integrating AI with SAP Joule, or a data-driven decision-maker using SAP Embedded Analytics, there’s a suitable tool for everyone in the SAP ecosystem. Choosing the right tool can make all the difference, helping you achieve your goals more efficiently. Happy coding and innovating!

Highlights of the SAP S/4HANA Cloud Public Edition 2408 Release

2024-07-24T11:36:16.508000+02:00

The second major release of the year 2024 is here! The SAP S/4HANA Cloud Public Edition 2408 release is filled with innovations that boost your productivity and support your everyday work life.

I am thrilled to give you further insights on our fully-fledged cloud ERP, supporting your journey to the intelligent, sustainable enterprise in this blog post.

If you prefer rather watching than reading, you are welcome to check out my product update video:

Figure 1: Check out my top highlights of the release in this video.

Before I start with feature-based innovations, I am proud to announce that we have generally uplifted our system availability service level agreement for SAP S/4HANA Cloud Public Edition and Integrated Business Planning from 99.7% to 99.9% for all our customers. This leap signals our reliability and the investments into technology, hardware, procedures, and automation that we continuously make to deliver a world-class SaaS ERP service to you. This marks another superior level of service availability and helps customers to plan business operations with greater precision at less risks. To put it into context: This cuts the upgrade downtimes by another 66%.

The new service level agreement sets a high standard for our cloud operations moving forward.

And there’s more: Since mid-July, GROW with SAP premium subscription has expanded to include SAP Sales Cloud and Concur Expense solutions. Both enhances our Cloud ERP and gives it more horizontal width to allow customers bring more use cases onboard our solution.

And we keep the good news coming! While delivering more functional and technical based value to our public cloud customers, we reduce the complexity of monetizing digital business models by bringing contract accounting and invoicing capabilities into the core SAP S/4HANA Cloud Public Edition offering. With the 2408 release, SAP S/4HANA Cloud Public Edition for contract and accounting will be part of GROW with SAP. We are giving our customers full access to the high volume, high performance and high automation invoicing, and subledger solution that focuses on service, subscriptions, pay-per-use, and multi-sided business models, without extra metering based on revenue and expenses. No action required for our existing GROW customers, the expanded functionality is included up to their licensed GROW FUEs and will automatically become available from SAP S/4HANA Cloud Public Edition 2408 for all customers.

Learn more about GROW here: https://www.sap.com/products/erp/grow.html

Figure 2: Discover the value of GROW with SAP.

We offer you even more room to GROW: Constantly updating our methodology stays important! For this release, we are excited to announce significant updates to our GROW Adoption Plan, designed to streamline and enhance the adoption process for customers and partners. By integrating new deliverables and accelerators into the GROW Adoption Plan and SAP Cloud ALM, companies can achieve a faster and more efficient implementation experience. This release features GROW Adoption Plan tagging, combining new adoption deliverables and related accelerators, including the Multi-Country Deployment and Application Lifecycle Management accelerators with new content. Additionally, our updated quality gates now include the first iteration of adoption elements, which will further integrate into SAP Cloud ALM.

Available for some time, but in between releases and therefore, potentially new to some, we are also offering our customers guidance for transitioning from the two-system-based landscape to the three-system landscape of SAP S/4HANA Cloud Public Edition.

Figure 3: We are offering our customers guidance for transitioning from the two-system-based landscape to the three-system landscape of SAP S/4HANA Cloud Public Edition.

Also, SAP introduces new sustainability capabilities to support organizations in meeting their sustainability ambitions and goals as well as regulatory requirements. These include automated ESG reporting via the SAP Sustainability Control Tower and AI-enhanced carbon footprint calculations through the SAP Sustainability Footprint Management solution. Additionally, both solutions feature a carbon calculator engine for comprehensive emissions reporting, and the upcoming SAP Green Ledger will integrate greenhouse gas emissions into financial decision-making.

Speaking of artificial intelligence: A lot has happened here in the past months. With SAP’s Business AI strategy, we are defining the future by embedding SAP Business AI along our entire portfolio:

Relevant – Reliable – Responsible

Figure 4: With SAP Business AI, we accelerate your business processes and optimize decision-making.

Enough upfront news–without any further ado, let’s check out what I additionally consider as highlights of the SAP S/4HANA Cloud Public Edition 2408 release.

Modern and Intelligent Experience

SAP User Experience

Through artificial intelligence, we help to get your work done faster and change the user experience–starting with our generative AI copilot, Joule. After a successful phased roll-out in the Early Adopter Care program, Joule will grace your SAP S/4HANA Cloud Public Edition system with a continuous delivery shipment very soon, at current state of planning in quarter 3/2024. Joule works as follows: Formulate your business need in natural language and Joule will provide easy access to applications and data, lowering manual tasks and boosting productivity.

Figure 5: Our natural-language, generative AI copilot Joule provides easy access to applications and data.

SAP Business AI offers you a cutting-edge SAP Fiori experience via smart summarization and easy filter. Smart summarization jump starts your collaboration or follow-up by extracting the essential information of the object pages of the SAP Fiori elements applications you are using in the system. With easy filter, you can select data of “list report-based" SAP Fiori apps instead of defining filter values manually. All of this in natural language. These AI use-cases are available in beta testing. Check out the SAP Customer Influence page to sign up: https://influence.sap.com/sap/ino/#campaign/3698

Figure 6: AI-assisted smart summarization extracts the essential information of the object pages of the SAP Fiori elements apps you’re using in the system.

Figure 7: With easy filter, you can select data of “list report-based" SAP Fiori apps instead of defining filter values manually.

To enhance transparency around significant system changes, we’ve established a scalable communication strategy, allowing the delivery of important messages to specifically chosen customers and users, following the "need-to-know" principle. This in-app communication was highly requested by our customers and partners through advisory groups and our influence portal and permits us to spotlight essential customer activities in the system. Catering messages to such specific requirements facilitates delivering reminder information solely to those customers who haven't yet performed important requisite system activities and those users who possess the necessary authorization to carry out these tasks. A first example of this approach is the targeted communication pertaining to SAP Fiori launchpad settings, i.e., the switch to spaces and pages.

Figure 8: Target users get system pop-ups after login showing critical must-dos and must-knows for their user role including a linked document for details.

Finance

In finance, we introduce new review booklet for cost centers. This app provides a concise display of both actual and planned costs, organizing several predefined reports under 'Actuals' and 'Plan/Actuals' pages. It provides business applications that embed crucial insights into the relevant business context, supporting the answering of critical business queries effectively and efficiently. It seamlessly integrates application logic, guidance, and multidimensional insights and upholds the promise of "insight to action" within embedded analytics, enabling users to analyze actuals and plan data in a single report while providing the flexibility to toggle between guided views and generic slicing, dicing, and pivoting based on specific business requirements.

Figure 9: Display, analyze, and validate cost center data with the new review booklet.

Additionally, we enable you to analyze and summarize data from the cost-center review booklet into actionable financial business insights with the help of generative AI. This use case is available in beta testing. Check out the SAP Customer Influence page to sign up: https://influence.sap.com/sap/ino/#campaign/3698

Figure 10: Gain financial business insights with the help of generative AI.

GRC, Trade, and Tax

This release delivers an innovative experience in managing US-internal tax configuration powered by Joule. The process of maintaining tax jurisdiction codes and rates has been simplified from a dozen steps to only three! Users just can use a natural language prompt to retrieve detailed information from the AI, then verify, simulate, and save the configured tax jurisdiction codes and rates. Once the connection between your SAP system and the LLM is configured, users can chat directly with the AI to retrieve detailed address-based tax jurisdiction information. Furthermore, the LLM delivers links to the respective state tax or revenue authority, providing users with an easily accessible way to verify their tax rate information prior to simulating and saving the changes. This use case is currently available in beta testing. To register, check out the SAP Customer Influence page: https://influence.sap.com/sap/ino/#/campaign/3698

Figure 11: Joule helps to simplify the process of maintaining US-internal tax configuration.

Sales

One of the key highlights here is the auto-activation of the intelligent scenario for input recommendations for sales orders. This feature significantly boosts efficiency and cost savings by hastening the activation of the intelligent scenario for sales order recommendations. Implemented when scope item 73P gets activated, the system employs an auto-training mechanism that periodically trains the machine learning model based on the business data from the past year. Users have the flexibility to enable or disable this auto-training in the ‘Intelligent Scenario Management’ app. This functionality guarantees automatic set-up, training and operation of the intelligent scenario, making the sales order completion more efficient and intuitive while reducing costs.

Figure 12: Auto-activation of the intelligent scenario for input recommendations makes the sales-orders process more efficient and intuitive.

Product Compliance

With this release, we enable the generation of product compliance documents with integration into the safety data sheet process. Users can now generate a first selection of sections of an EU safety data sheet (without country/region-specific additions) for product compliance solutions using Adobe Document Services. This not only extends the product compliance solution with integrated document generation capability but also streamlines the generation of documents for product compliance data. This is based on versatile Adobe form templates and form data providers. The generated documents are seamlessly integrated into the safety data sheet process. This also comes with new apps to manage and release data for handling and storage as well as stability and reactivity of products, making it a comprehensive tool for product compliance.

Figure 13: You can now easily generate a first selection of sections of an EU safety data sheet using Adobe Document Services.

ERP Innovations

Manufacturing

SAP S/4HANA Cloud Public Edition 2408 introduces advancements in the ‘Monitor Material Coverage’ SAP Fiori apps. The ‘Monitor Material Coverage – Net Segments’ and the ‘Monitor Material Coverage – Net and Individual Segments’ apps now offer additional columns displaying the number of rescheduling proposals for a material. This improvement assists businesses in avoiding supply shortages or an excess of supplies. This is achieved by indicating the number of Material Requirements Planning (MRP) supplying elements with rescheduling proposals for each material. Additionally, the system can reschedule in, reschedule out, or cancel a process based upon a calculation for the entire planning horizon. The enhanced features enable better management of supply shortages and excess supply with MRP material coverage apps, providing a more effective and streamlined operation.

Figure 14: Manage supply shortages or excess supply with additional columns in the ‘Monitor Material Coverage’ SAP Fiori apps.

Supply Chain Management

In this release, we ship the warehouse-driven split of the outbound delivery order. This feature empowers organizations to separate packed and unpacked items, quantities, or handling units from an existing outbound delivery order into a new one. This offers increased flexibility in case a complete picking is not possible, added functionality if space in the truck is limited, and the ability to split outbound delivery order items for which no warehouse task has been created yet. It’s also possible to split handling units into a new outbound delivery order. The release therefore provides businesses with improved logistical abilities, offering greater adaptability in managing outbound delivery orders.

Figure 15: The warehouse-driven split of the outbound delivery order empower organizations to separate packed and unpacked items, quantities, or handling units from an existing outbound delivery order into a new one.

Solution and Subscription Business

Here, I want to highlight a feature from the latest CFD release which I believe has huge business value for organizations transitioning to solution-led business models. The introduction of advanced solution bundling enables you to pre-configure complex solution orders which can contain multiple configurable and non-configurable items, and sell them on a single solution order, providing greater flexibility whilst saving effort on manual input. This enables the sale of complex end-to-end solution offerings tailored to specific customer needs.

Figure 16: Pre-configured bundles can be added to a solution order and processed for further fulfilment.

Service

In this release, we enable you to add maintenance plan templates in service contracts. This enhancement simplifies the workflow drastically, particularly for those dealing with service contracts that include maintenance plans. During the creation process of service contract templates, you can already add maintenance plan templates to service contract items. After creating a service contract from a service contract template, the maintenance plan templates are also copied. When you release a service contract item, a new maintenance plan is automatically created using the maintenance plan template. If you don’t use service contract templates, you can add maintenance plan templates directly in a service contract.

Figure 17: Maintenance plan templates facilitate the service contract process significantly.

Enterprise Porfolio and Project Management

To better support the engineer-to-order process, we ship an innovation to reserve materials using project demand. When it comes to project demands, we offer three categories: resources, services, and materials. In the category of materials, we now offer ‘Project Stock Reservation’. A project procurement controller or project manager can select the WBS element, the plant, the material ID, the quantity, and eventually also the storage location, and then reserve material for a project on a certain date. Once the demand is requested, a reservation number gets generated. With the monitoring capabilities, you can view how many quantities have been delivered in case certain quantities in stock are issued against the material. This creates transparency for the project procurement controller.

Figure 18: The ability to reserve material using project demand makes workflows more efficient and project management more effective.

Professional Services

The shared risk-based revenue recognition for professional service projects feature addresses potential customer projects that exceed the initial scope, allowing service providers to bill at regular rates before charging reduced rates for any additional work. A new revenue recognition key (SPTMSR) supports this shared risk model. This enables more precise revenue recognition where additional work is required, increasing flexibility for revenue recognition and reducing manual efforts to adjust accrued revenues. In this model, if the need for additional work is identified, the system considers the reduced rate during revenue recognition. The feature signifies an important step towards enhancing accounting accuracy and transparency in service-oriented sectors, promoting mitigation of financial risk, and improving overall project management.

Figure 19: Shared risk-based revenue recognition for professional service projects enhances accuracy and transparency.

Sourcing and Procurement

A purchase contract is an agreement between a buyer and a supplier with agreed pricing, quantity, terms, and conditions. Since purchase contracts are long-term documents, they are subject to change over time. By enabling versioning of purchase contracts, businesses can meticulously track various versions of contracts each time a modification is made to an active purchase contract. Following alterations to fields set for versioning, the system automatically creates a new version. The new version can then become an active document, subject to the approval process. The versioning feature enhances transparency and efficiency by enabling comparisons between two document versions, including changes notable in pricing. This function ultimately aids in fostering improved collaboration between buyers and suppliers.

Figure 20: Versioning in purchase contracts fosters improved collaboration between buyers and suppliers.

Asset Management

In this release, we introduce an enhanced feature of recording the "As-Found" condition in the 'Perform Maintenance Jobs' app. The app offers maintenance technicians an improved way to record the initial condition of an asset during proactive and routine maintenance jobs, even when the maintenance order does not have a maintenance notification assigned. If the specific technical object differs from the overall order header, a new notification will be created automatically while the technician records the "As-Found" condition. Previously, the malfunction data tab was enabled only if the order has an associated notification. Now, these tabs are accessible by default in orders with notifications. Additionally, configurations can allow users to maintain malfunction data, thereby providing users with better recording of asset reliability data which in turn enhances the overall user experience.

Figure 21: We enhance the recording of the “As-Found” condition in the ‘Perform Maintenance Jobs’ app.

Environment, Health, and Safety

A new application for managing the investigation process significantly improves the tracking and oversight of investigation projects, allowing for more effective and efficient processes. The ‘Manage Investigations’ app offers a comprehensive platform where pertinent details such as investigation phase, persons involved, and timelines can be meticulously documented and managed. Administrators can determine the course and progression of investigations, and delegate necessary tasks for seamless operation. This new tool pursues both procedural integrity and simplicity, with a user-friendly interface coupled with robust functionality. Ultimately, it enhances user experience, strengthens accountability, and fosters greater efficiency in managing the investigation process.

Figure 22: The new ‘Manage Investigations’ app fosters great efficiency in managing the investigation process.

Two-Tier ERP

In two-tier ERP, Tier 1 acts as an original equipment manufacturer on SAP S/4HANA Cloud Private Edition and Tier 2 acts as a service subsidiary on SAP S/4HANA Cloud Public Edition. With this set up, organizations can perform claims processing and subsequent reimbursements between their service organization and original equipment manufacturer. In this release, we introduce a refined warranty claim process, aiding you in effectively managing and navigating through the complexities of warranty claims. The process offers improved visibility into various aspects such as claim creation, processing, submission, and tracking. In addition, the solution accelerates assessment and administration of warranty claims with built-in automation that streamlines the end-to-end warranty management. As a part of service management, this efficient mechanism ensures quicker resolution time, reducing both manual effort and the overall operating cost for the business. Essentially, the enhancement in the warranty claim process signifies an evolution towards improved customer satisfaction and a more strategic approach to service operations.

Figure 23: The new warranty claim process offers improved customer satisfaction and a more strategic approach to service operations.

SaaS Foundation

Extensibility

The cloud extensibility model with a three-system landscape in SAP S/4HANA Cloud Public Edition enables customers to seamlessly leverage SAP innovations, resulting in future-proof extensions that are compliant throughout their lifecycle and do not require adjustments during cloud innovation cycles. With this model, we can develop cloud-ready business apps, services, or custom extensions that are both upgrade-stable and cloud-ready. With developer extensibility, as a customer or partner, you can use one-off delivery for ABAP development intended to remain within your SAP S/4HANA Cloud landscape which enables you to import the developed custom ABAP code in a three-system landscape into the test and production system of the current landscape.

With multi-off delivery, we take it a step further. Custom development can be performed by a partner on behalf of a customer, in a separate development system which is not connected to the customer landscape, and then deployed on the customer's three-system landscape using the ‘Git-Enabled Change and Transport System’ (gCTS). The source code of ABAP extensions is stored in remote Git repositories, with gCTS being used to transfer (push and pull) the ABAP custom code between SAP S/4HANA Cloud landscapes and Git repositories. This is especially useful for scenarios where source and target landscapes can't be connected via transport routes. The SAP Fiori app ‘Git-Enabled CTS (gCTS)’ helps to manage tasks such as connecting to remote Git repositories, pushing and pulling commits, and managing branches. Commits are created in the development environment using ABAP development tools for Eclipse (ADT) when a task of a transport request is released. Find more information here.

Figures 24 & 25: Multi-off delivery brings a multitude of possibilities for custom development.

Public Sector Management

Public sector functionality within SAP S/4HANA Cloud Public Edition is broadening in terms of geographical availability. In addition to the US, Canada, and Germany, services such as grants management, budget management, and fund accounting is now also available in the UK, the Netherlands, and Australia. The global deployment of our service has started and is gaining great momentum. Be prepared for the availability in additional countries by the year 2025.

Additionally, we bring new, comprehensive budget management functionalities:

Addition of a Substitution Tool for Budget Maintenance.
Enhancement allowing the consumption of budget for expected expenses rather than the posting date.
Feature to check Public Sector budget availability using project hierarchies.
Updates to facilitate the generation of budget documents.
Improved reporting on budgets versus payments and open invoices.

Figure 26: This release includes significant updates to the early release enablement cycle for public sector.

R&D Engineering

In this release, we ship the integration of CAD design for data and file management. With this SAP Product Lifecycle Management solution, seamless interaction between engineering designs and SAP business processes is now feasible, i.e., you can easily transfer engineering bills of material (EBOMs) from the SAP Product Lifecycle Management solution and continue to work on them as manufacturing bills of material (MBOMs) in the relevant ‘Maintain Bill of Material (Version 2)’ app. The CAD tools extend their capabilities by being able to store files in the SAP PLM Product Data Integration (PDI), leading to the development of an Enterprise Product Structure within SAP’s Product Lifecycle Management. This integration simplifies the transfer of product data via product handover to SAP S/4HANA Cloud Public Edition, reducing the number of interfaces and facilitating a smoother operation. The end result is higher efficiency in engineering processes, holistic product description for increased transparency, and reduced operating costs. Overall, it signifies a major stride towards optimizing product data management in industry-specific CAD applications.

Figure 27: The integration of CAD design for data and file management enhances your engineering processes.

Business Partner Data

This release presents an enhancement in data privacy management, allowing users to concurrently assign data controllers along with specific purposes to business partners. This upgrade significantly bolsters the concept of “privacy by design and default” by permitting users the flexibility to manually or automatically attach data controllers to business partners. With options to leverage this feature via the ‘Maintain Business Partner’ and ‘Manage Business Partner’ SAP Fiori apps or through API channels, businesses can effectively manage their partner master data. This advancement not only ensures timely compliance with stringent data protection regulations but also molds business processes to instill trust among partners and customers. By enhancing the data privacy landscape, this feature equips businesses with the edge to meet legal requirements and foster a venerable relationship with their customers.

Figure 28: You can now assign data controllers along with specific purposes to business partners.

Information Lifecycle Management

SAP Information Lifecycle Management (SAP ILM) allows users to manage the lifecycle of live and archived data. Users can set rules for managing data throughout its lifecycle, specifying how long it should stay in the database, how long it should be archived, and when it should be deleted. This can be done consistently across development, test, and production systems. With the 2408 release of SAP S/4HANA Cloud Public Edition, one key feature is the self-service configuration user interface (SSCUI). This tool allows users to centrally maintain SAP ILM settings and transport them across the system landscape i.e., development, test and production systems, reducing the risk of errors and inconsistencies. Another key feature with this release is the storage of archive files to SAP HANA Cloud data lake files, ensuring fast and efficient access to archived data. Previously, these files were stored in the Neo platform. This change helps to store the SAP ILM archive files on a future-proof, fast, and cost-efficient technology stack, supporting both SAP ILM use cases: data volume management and data privacy. This change exclusively affects the underlying technology stack, with no impact on usability.

You can find more information here.

Figures 29 & 30: SAP Information Lifecycle Management (SAP ILM) allows users to manage the lifecycle of live and archived data.

Identity and Access Management

Unlock the full potential of SAP S/4HANA Cloud Public Edition with the unified access to documentation about Identity and Access Management (IAM) on SAP Help Portal! With this, we provide a simplified, one-stop shop for all IAM-related documentation, making it easier for users to access everything you need to know about user and identity management, roles, authorization, and authentication. The documentation covers all IAM-related tasks in the different phases of implementation (prepare, realize, run, and upgrade) making the process more streamlined and efficient. This unified access to IAM documentation provides a holistic view on IAM for SAP S/4HANA Cloud and integrated products from initial system access to tasks which need to be completed before, during, and after upgrading SAP S/4HANA Cloud and allows you to familiarize yourself with its key concepts.

Figure 31: Check out the documentation about Identity and Access Management on SAP Help Portal.

Summary

You see, the world is turning fast, and we keep you at the forefront of progress–but these are by far not all innovations we have in store with SAP S/4HANA Cloud Public Edition 2408. Stay tuned for the individual blog posts diving deeper into selected lines of business and industries.

Don’t hesitate to leave a comment and check out our community page to ask your questions and engage with the experts. Follow the PSCC_Enablement tag to stay up to date with our latest blog posts.

📽️ Watch the Replays of Our SAP S/4HANA Cloud Public Edition 2408 Early Release Series!

From July 8 to July 12, we hosted a series of 20 compelling live sessions to highlight the exciting innovations shipped with the SAP S/4HANA Cloud Public Edition 2408 release. Missed the live sessions? We've got you covered! Take advantage of the entire series or pick and choose the sessions most relevant to you. Don't miss this chance and watch them on demand–anywhere, anytime.

🔎Find All of Our Assets

Hey developers: Want to attend your own version of Oktoberfest?

2024-07-25T11:59:35.716000+02:00

Hi folks,

For any new developers out there that are familiarizing themselves with SAP, I thought I should share a yearly event designed to bring SAP devs together to have some fun.

What is Devtoberfest by SAP TechEd?

Devtoberfest by SAP TechEd is an event designed to capture the energy and creativity of pre-conference activities like the SAP InnoJam, but it's more than just a hackathon. It's a more flexible and inclusive celebration everything that makes developers thrive — coding, learning, and collaboration. This event marks the kickoff to the SAP TechEd season, offering a multi-week festival that fits everyone's schedules; whether you like to join live sessions or prefer learning asynchronously.

Getting Started with Devtoberfest by SAP TechEd

To join the festivities, all you have to do is join the event group within this community. There's no need to register on a third-party event site or link to your SAP Community account manually.

What's in Store for 2024?

Educational Content

A key feature of Devtoberfest by SAP TechEd is its rich educational content. Daily sessions will be released every weekday during the event. This content is designed for you to consume at your own pace, ensuring that you can fit learning into your own schedule. These sessions will cover a variety of topics, from beginner fundamentals to advanced SAP techniques.

For a sneak peek at what to expect, you can review the content from Devtoberfest 2023, but remember that the official agenda for 2024 will be announced in the event group closer to the event date.

The Contest

The contest component of Devtoberfest by SAP TechEd adds a competitive edge to the event, offering participants the chance to win prizes. Following the success of 2022's year's grand prize— a retreat to Newport Beach and Disneyland— we brought it back for 2023. Stay tuned for the 2024 prize!

Fun Activities

Fun Friday activities will return this year, featuring events that encourage community collaboration. From scavenger hunts to coding puzzles, these activities are designed to be flexible with your schedule.

Mark Your Calendars

Devtoberfest by SAP TechEd 2024 will span two main phases:

September 23rd to October 14th, 2024
October 4th to October 25th, 2024

Each day will offer something new, so make sure you're checking the SAP Community Events calendar regularly.

How to start

To get started, join the event group and stay tuned for more updates as we approach the start date. In the meantime, feel free to explore the 2023 content to get a feel for what’s coming.

Have fun!

- David