SAP Community - SAP S/4HANA Cloud Extensibility

SAP S/4HANA Cloud ABAP开发案例之七：库龄报表

2024-03-11T08:40:07.661000+01:00

紧随这篇博客，今天我们将再次逐步详细地介绍一个利用SAP S/4HANA Cloud三系统来做开发扩展的案例。

1. 案例背景

库龄报表是大多数客户都会询问和想要的一张报表。它以逆时间顺序概述了一段时间内从选定的关键日期开始的可用物料库存的分布情况。但是，具体的需求可能因客户而异。例如，一些客户可能希望在计算物料库龄信息时只考虑某些移动类型。通过利用开发人员可扩展性，我们开发了一个定制的库龄报表，并嵌入到SAP S/4hana Cloud系统中。此外，客户可以完全灵活地定义哪些移动类型将包括在库龄报告的计算中。

同时，我们配置了一个Custom Business Configuration项目，我们可以把希望被统计在库龄报表里的移动类型维护在这个表格内，如下图。

2. 后台服务开发

2.1 创建数据定义

创建一个新的数据定义（Data Definition）：Z_MATERIAL_STOCK_AGE

2.2 创建查询实现类

创建类ZCL_MATERIAL_STOCK_AGE，在这个类里包含了基于CDS视图的数据查询逻辑。

CLASS zcl_material_stock_age DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_rap_query_provider .
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.



CLASS ZCL_MATERIAL_STOCK_AGE IMPLEMENTATION.


  METHOD if_rap_query_provider~select.
    IF io_request->is_data_requested( ).

      TYPES BEGIN OF ty_value.
      TYPES: quantity TYPE i_stockquantitycurrentvalue_2-matlwrhsstkqtyinmatlbaseunit,
             value    TYPE i_stockquantitycurrentvalue_2-stockvalueindisplaycurrency.
      TYPES END OF ty_value.

      TYPES:
        BEGIN OF ty_range_option,
          sign   TYPE c LENGTH 1,
          option TYPE c LENGTH 2,
          low    TYPE string,
          high   TYPE string,
        END OF ty_range_option.


      DATA: lt_response        TYPE TABLE OF z_material_stock_age,
            ls_response        LIKE LINE OF lt_response,
            lt_responseout     LIKE lt_response,
            ls_responseout     LIKE LINE OF lt_responseout,
            lt_response_period TYPE TABLE OF z_material_stock_age,
            ls_response_period LIKE LINE OF lt_response_period,
            lt_value           TYPE TABLE OF ty_value,
            ls_value           TYPE ty_value,
            lv_price           TYPE p DECIMALS 2,
            lt_configr         TYPE TABLE OF ty_range_option,
            ls_configr         LIKE LINE OF lt_configr.


      DATA(lv_top)           = io_request->get_paging( )->get_page_size( ).
      DATA(lv_skip)          = io_request->get_paging( )->get_offset( ).
      DATA(lv_max_rows) = COND #( WHEN lv_top = if_rap_query_paging=>page_size_unlimited THEN 0
                                  ELSE lv_top ).

      DATA(lt_clause)        = io_request->get_filter( )->get_as_ranges( ).
      DATA(lt_parameter)     = io_request->get_parameters( ).
      DATA(lt_fields)        = io_request->get_requested_elements( ).
      DATA(lt_sort)          = io_request->get_sort_elements( ).

      TRY.
          DATA(lt_filter_cond) = io_request->get_filter( )->get_as_ranges( ).
        CATCH cx_rap_query_filter_no_range INTO DATA(lx_no_sel_option).
      ENDTRY.

****************************Data selection and business logics goes here*********************************
      LOOP AT lt_parameter ASSIGNING FIELD-SYMBOL(<fs_p>).
        CASE <fs_p>-parameter_name.
          WHEN 'P_KEYDATE'.   DATA(p_keydate) = <fs_p>-value.
        ENDCASE.
      ENDLOOP.

      LOOP AT lt_filter_cond INTO DATA(ls_filter_cond).
        IF ls_filter_cond-name = 'STROAGELOCATION'.
          DATA(lt_storagelocation) = ls_filter_cond-range[].
        ELSEIF  ls_filter_cond-name = 'MATERIAL'.
          DATA(lt_material) = ls_filter_cond-range[].
        ELSEIF  ls_filter_cond-name = 'PLANT'.
          DATA(lt_plant) = ls_filter_cond-range[].
        ELSEIF  ls_filter_cond-name = 'COMPANYCODE'.
          DATA(lt_bukrs) = ls_filter_cond-range[].
        ENDIF.
      ENDLOOP.

*get configuration data
      SELECT * FROM zmovementtype WHERE bukrs IN @LT_bukrs
                                  AND inuse = @abap_true
                                  INTO TABLE @DATA(lt_config).

      LOOP AT lt_config INTO DATA(ls_config).
        ls_configr-sign = 'I'.
        ls_configr-option = 'EQ'.
        ls_configr-low = ls_config-movementtype.
        APPEND ls_configr TO lt_configr.
        CLEAR ls_configr.
      ENDLOOP.

*get inventory information based on date
      SELECT *
      FROM i_materialstock_2
      WHERE storagelocation IN @LT_storagelocation
      AND material IN @LT_material
      AND matldoclatestpostgdate <= @p_keydate
      AND plant IN @LT_plant
      AND companycode IN  @LT_bukrs
      INTO TABLE @DATA(lt_stock).

      LOOP AT lt_stock INTO DATA(ls_stock).
        ls_response-companycode = ls_stock-companycode.
        ls_response-plant = ls_stock-plant.
        ls_response-material = ls_stock-material.
        ls_response-stroagelocation = ls_stock-storagelocation.
        ls_response-currentstock = ls_stock-matlwrhsstkqtyinmatlbaseunit.
        COLLECT ls_response INTO lt_response.
      ENDLOOP.

*period start date calculation
      DATA lv_30 TYPE d.
      DATA lv_60 TYPE d.
      DATA cd TYPE d.
      cd = p_keydate.
      lv_30 = cd - 30.
      lv_60 = cd - 60.

*get material movement history
      SELECT *
      FROM i_materialdocumentitem_2
      FOR ALL ENTRIES IN @LT_response
      WHERE storagelocation = @LT_response-stroagelocation
      AND postingdate <= @p_keydate
      AND plant IN @LT_plant
      AND companycode IN @LT_bukrs
      AND material = @LT_response-material
      AND goodsmovementtype in @LT_configr
      AND goodsmovementiscancelled IS INITIAL
      INTO TABLE @DATA(lt_movement).

      DATA(lt_movement_reverse) = lt_movement[].

      LOOP AT lt_movement INTO DATA(ls_movement).
        READ TABLE lt_movement_reverse WITH KEY  reversedmaterialdocumentyear = ls_movement-materialdocumentyear
                                                 reversedmaterialdocument = ls_movement-materialdocument
                                       TRANSPORTING NO FIELDS.
        IF sy-subrc = 0.
          DELETE lt_movement FROM ls_movement.
        ENDIF.
      ENDLOOP.

      LOOP AT lt_movement INTO ls_movement WHERE reversedmaterialdocument IS INITIAL.
        ls_response_period-companycode = ls_movement-companycode.
        ls_response_period-plant = ls_movement-plant.
        ls_response_period-material = ls_movement-material.
        ls_response_period-stroagelocation = ls_movement-storagelocation.
        ls_response_period-meins = ls_movement-materialbaseunit.
        ls_response_period-waers = ls_movement-companycodecurrency.

        IF ls_movement-postingdate > lv_30 AND ls_movement-postingdate <= cd.
          ls_response_period-period1 = ls_movement-quantityinbaseunit.
        ELSEIF ls_movement-postingdate > lv_60 AND ls_movement-postingdate <= lv_30.
          ls_response_period-period2 = ls_movement-quantityinbaseunit.
        ELSEIF ls_movement-postingdate <= lv_60.
          ls_response_period-period3 = ls_movement-quantityinbaseunit.
        ENDIF.

        COLLECT ls_response_period INTO lt_response_period.
        CLEAR ls_response_period.
      ENDLOOP.

      LOOP AT lt_response INTO ls_response.
        READ TABLE lt_response_period WITH KEY companycode = ls_response-companycode
                                               plant = ls_response-plant
                                               material = ls_response-material
                                               stroagelocation = ls_response-stroagelocation
                                      INTO ls_response_period.

*        ls_response-meins = ls_response_period-meins.
*        ls_response-waers = ls_response_period-waers.

        IF sy-subrc = 0.
* period 1 calculation with 30 days.
          IF ls_response-currentstock < ls_response_period-period1 AND ls_response_period-period1 > 0.
            ls_response-period1 = ls_response-currentstock.
          ELSE.
            ls_response-period1 = ls_response_period-period1.
          ENDIF.
* period 2 calculation between 30 days to 60 days.
          IF ( ls_response-currentstock - ls_response_period-period1 )  < 0.
            ls_response-period2 = 0.
          ELSEIF ( ls_response-currentstock - ls_response_period-period1 ) < ls_response_period-period2 AND ls_response_period-period2 > 0.
            ls_response-period2 = ls_response-currentstock - ls_response_period-period1.
          ELSEIF ( ls_response-currentstock - ls_response_period-period1 ) >= ls_response_period-period2.
            ls_response-period2 = ls_response_period-period2.
          ENDIF.
* period 3 calculation more than 60 days
          IF ( ls_response-currentstock - ls_response_period-period1 - ls_response_period-period2 )  < 0.
            ls_response-period3 = 0.
          ELSEIF ( ls_response-currentstock - ls_response_period-period1 - ls_response_period-period2 ) < ls_response_period-period3 AND ls_response_period-period3 > 0.
            ls_response-period3 = ls_response-currentstock - ls_response_period-period1 - ls_response_period-period2.
          ELSEIF ( ls_response-currentstock - ls_response_period-period1 - ls_response_period-period2 ) >= ls_response_period-period3.
            ls_response-period3 = ls_response_period-period3.
          ENDIF.

        ELSEIF sy-subrc > 0 AND ls_response-currentstock > 0.
          ls_response-period3 = ls_response-currentstock.
        ENDIF.

* getting price information
        SELECT SUM( matlwrhsstkqtyinmatlbaseunit ) AS quantity,
               SUM( stockvalueincccrcy ) AS value
               FROM i_stockquantitycurrentvalue_2( p_displaycurrency = 'CNY' )
               WHERE product = @LieneS_response-material
               AND plant = @LieneS_response-plant
               AND storagelocation = @LieneS_response-stroagelocation
               AND valuationareatype = 1
               GROUP BY product,plant,storagelocation
               INTO TABLE @LT_value.

        IF sy-subrc = 0.
          CLEAR: ls_value,
                 lv_price.
          READ TABLE lt_value INTO ls_value INDEX 1.
          IF ls_value-quantity NE 0.
            lv_price = ls_value-value / ls_value-quantity.
          ENDIF.
        ENDIF.

* calculate value information
        ls_response-currentvalue = ls_response-currentstock * lv_price.
        ls_response-period1_v = ls_response-period1 * lv_price.
        ls_response-period2_v = ls_response-period2 * lv_price.
        ls_response-period3_v = ls_response-period3 * lv_price.

        MODIFY lt_response FROM ls_response.
        CLEAR ls_response.
      ENDLOOP.

*paging way to return huge amount of data
      SORT lt_response BY stroagelocation material.
      lv_max_rows = lv_skip + lv_top.
      IF lv_skip > 0.
        lv_skip = lv_skip + 1.
      ENDIF.

      CLEAR lt_responseout.
      LOOP AT lt_response ASSIGNING FIELD-SYMBOL(<lfs_out_line_item>) FROM lv_skip TO lv_max_rows.
        ls_responseout = <lfs_out_line_item>.
        APPEND ls_responseout TO lt_responseout.
      ENDLOOP.

      io_response->set_total_number_of_records( lines( lt_response ) ).
      io_response->set_data( lt_responseout ).

    ENDIF.
  ENDMETHOD.
ENDCLASS.

2.3 创建服务定义和服务绑定

创建服务定义（Service Definition）

创建服务绑定（Service Binding）

我们可以看到服务预览如下：

3. 前台应用开发

首先，在BTP上配置destination。

然后，打开SAP Business Application Studio服务。

从Application Generator里选取SAP Fiori Worklist Application模板。

把应用部署到SAP S/4HANA Public Cloud系统。

以上是该案例——库龄报表自开发应用的步骤介绍。希望通过此案例的介绍能让您了解到三系统开发能实现的常见功能。

What's New? Overview of Changes in Extensibility Objects in SAP S/4HANA Cloud Public Edition

2024-03-15T20:23:58.478000+01:00

Are you excited about the new releases and updates of SAP S/4HANA Cloud Public Edition? And do you want to understand which new extensibility capabilities you‘re getting right away? Do you want to know which new extensibility objects you can use to build your custom apps or extensions?

If you do, there's a URL you should bookmark and check out:

https://help.sap.com/S4_CE_CHANGES_EXT_OBJ

Starting with SAP S/4HANA Cloud Public Edition 2402.1., this is your central entry point for an overview of changes in extensibility objects in the current release/update. In this What's New document, you'll find a central table that informs you about changed, deleted, deprecated, or new extensibility objects, such as business object interfaces, CDS views, or remote APIs. With different filter options, you can drill down to the objects and changes you're interested in.

All three extensibility options in SAP S/4HANA Cloud Public Edition are covered:

Developer extensibility
Key user extensibility
Side-by-side extensibility

In previous releases, changes to extensibility objects were announced in individual What's New documents under different categories, such as API, CDS View, or Extensibility. Now, they’re available to you in this overview table in one single What’s New document.

For a brief overview of what you'll find in the central table, watch the following video:

Changes to the following main object types relevant for extensibility are listed:

Authorization objects
BAdIs
Business object interfaces
Business events
CDS views
Classes
Data elements
Interfaces
OData V2 APIs
OData V4 APIs
SOAP APIs

We hope that this overview enables you to quickly explore new extensibility scenarios in SAP S/4HANA Cloud Public Edition - based on your individual business requirements.

Start extending SAP S/4HANA Cloud Public Edition with SAPUI5 adaptation projects

2024-03-22T18:40:55.511000+01:00

See the simple and effective changes you'll learn how to make to your application variant:

https://sapvideo.cfapps.eu10-004.hana.ondemand.com/?entry_id=1_5r7r5h0n

Start extending with SAPUI5 adaptation projects:

For more information, see Extending an SAP Fiori Application for SAP S/4HANA Cloud Public Edition

See my earlier post for more details: https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/learn-how-to-work-with-sapui5-adaptation-projects-to-extend-sap-s-4hana/ba-p/13607922

Announcing General Availability of SAP Build Code: Speed up development with generative AI

2024-03-27T03:00:00.041000+01:00

SAP is dedicated to increasing developer productivity enabling rapid extension of SAP S/4HANA and other enterprise applications. To support this mission, we announced SAP Build Code at TechEd 2023 and today, I’m excited to announce that it is generally available to all developers. Get started with the Test Drive tutorial!

What is SAP Build Code?

SAP Build Code provides AI-based code generation with Joule copilot, optimized for Java and JavaScript application development. It is a comprehensive, turn-key solution for coding, testing, integrations, and application lifecycle management. You can leverage Joule to efficiently generate application logic, data models, and test scripts. As an end-to-end integrated solution, SAP Build Code enhances the entire development process, from design time to runtime, significantly boosting your productivity.

Picture 1: Joule-powered code generation and visual representation of the code in SAP Build Code

SAP Build Code is tailored for SAP development, allowing you to utilize your favorite SAP programming models and frameworks and enabling you to connect seamlessly to S/4HANA and other applications with prebuilt integrations. It provides you with a guided development experience following best practices from SAP. The Service Center in SAP Build Code provides direct access to discovery and consumption of SAP APIs Including OData and Business Events from SAP and third-party systems. As an integral part of SAP Business Technology Platform (BTP), SAP Build inherits all the robust security and integration capabilities of BTP. This not only enhances security but also simplifies the development of extensions and applications for SAP S/4HANA and other enterprise applications following SAPs clean core strategy.

Picture 2: Direct access to SAP applications and data in SAP Build Code through the Service Center

But there's more – SAP Build Code encourages fusion development, an approach that uses a mix of traditional coding and low-code development. This is thanks to its support for app composability and the reuse of project components across SAP Build low-code solutions and ABAP environments. SAP Build Code makes your development process faster, more collaborative, and more integrated with the SAP ecosystem, perfect for those looking to streamline their development projects.

What developers are saying about SAP Build Code

Since announcing the solution, we’ve had 450 developers use SAP Build Code in our preview program. Here are a couple of my favorite quotes from the developers who have used SAP Build Code to build full-stack SAP Fiori applications so far:

"SAP Build Code is yet another great offering within the SAP BTP ecosystem. I'm impressed by its maturity and developer-friendly features that quickly get you up and running. Gone are the days of wrestling with your application logic and data models. With a thoughtful prompt, Joule can get your application logic and data models created and fully functioning in just a few clicks."
– Mark Smith, Senior Full-Stack Developer, Mindset Consulting

“SAP Build Code will enable rapid development and has all the features we require to build a full stack solution powered with generative AI, including pre-configured runtime and design time capabilities, enabling shorter lead time to market.”
– Nilesh Mhatre, CIO Americas, IMEA and Global Technology Center, Henkel

Try it yourself – take SAP Build Code for a Test Drive!

You can experience SAP Build Code with the Test Drive tutorial. This unique opportunity allows you to explore the full capabilities of SAP Build Code, including Joule-powered AI-based code generation, in the SAP BTP Trial, guided by the expertise of SAP Developer Advocates and the vibrant SAP Community.

By participating, you will not only gain hands-on experience with SAP Build Code but also have the chance to earn an SAP Community badge, recognizing your efforts and learning. This is an excellent way to enhance your skills, connect with fellow developers, and get a head start with SAP Build Code.

Don’t miss out – our free AI offer for early adopters

We are offering a limited quantity of Joule generative AI within the trial version of SAP Build Code. This allows you to experience the power of AI-assisted code development for free. Furthermore, if you move to the SAP Build Code, standard plan, there is a significant increase in the amount of free AI quantity you will receive from now until September 1, 2024.

➡️ Just another reason to get started early, so take the Test Drive and have fun!

10+ ways to reshape your SAP landscape with SAP Business Technology Platform - Blog 3

2024-03-28T14:14:59.178000+01:00

How Clean Core can accelerate your SAP Business Transformation

This blog is part of the “10+ ways to reshape your SAP landscape with SAP Business Technology Platform Blog Series”

Summary:
The SAP Clean Core strategy offers a straightforward way to simplify and improve the flexibility of managing SAP systems. It revolves around five key areas: Extensibility, Integrations, Data, Business Processes, and Operations. This approach lays out a clear plan for creating and keeping an IT environment that's quick to adapt and conducive to innovation. By adopting the Clean Core strategy's rules and recommendations, companies can make the most of new technologies from SAP and its partners, helping them thrive in the ever-changing business world.

In their book "Software Engineering at Google," authors Wright, Manshreck, and Winters share the idea that code should be regarded as a liability rather than an asset. They're getting at the fact that keeping code up and running isn't free—it needs constant care for maintenance, updates, and keeping it secure. As such, an abundance of complex code can significantly amplify operational costs due to the necessity for extensive maintenance.

The aspect of treating code as a liability can also be applied to your SAP landscape. Extending SAP systems is a common practice for many organizations. If it is not done in a reliable and responsible way, the systems end up in a complex state possibly carrying a lot of technical debt from the previous years. Such a state of high entropy is undesired, as it not only leaves the IT-landscape but also the complete organization in an inflexible state.

In the context of the current dynamic market landscape, it is imperative for organizations to possess the capability to swiftly adapt to evolving customer expectations, market dynamics, and industry trends. Given the pivotal role SAP systems play in implementing numerous business processes, this requires an agile approach to SAP system management, including the assimilation of recent SAP product advancements and promptly integrating the latest software releases.

The SAP Clean Core strategy is instrumental in realizing this vision. By advocating for a streamlined IT landscape centered around SAP S/4HANA as the digital core and augmenting it with cloud solutions tailored for specific business functions, organizations can diminish complexity, enhance adaptability, and effectively leverage the latest technological advancements from SAP and its partners. This strategic approach ensures a robust, agile, and innovation-friendly IT ecosystem conductive to sustained organisational success.

The 5 Dimensions of a Clean Core strategy

The SAP Clean Core approach is based on five technical and procedural components that work together to build and maintain an adaptable SAP landscape.

1. Extensibility

SAP systems are crucial for the smooth operation of many companies, offering a wide range of software solutions to handle key business tasks. Despite the extensive functionality offered by SAP, businesses may find that the standard offerings don't fully meet their specific needs. Extending an SAP system is often required to adapt to the unique processes, requirements, and challenges of a business. The Clean Core strategy suggests such extensions should:

be upgrade-stable following a prescribed extensibility model, as outlined in the SAP S/4HANA Extensibility Guide, using Key-User and On-Stack extensibility on SAP S/4HANA and Side-by-Side approaches on SAP Business Technology Platform.
use released APIs and events as defined in the SAP Business Accelerator Hub.
be actively used and have detailed documentation.
follow high standards for coding quality and best practices, which could include mandatory approvals for classic extensions, for example.
not repeat something that SAP or its partners already offer.

By meeting these guidelines, you reduce the risk that custom extensions disrupt updates to SAP's standard offerings.

Implementing decoupled extensions on the SAP Business Technology Platform (SAP BTP) provides extra flexibility by offering an independently scalable environment. This setup supports project implementations that have their own software development lifecycle and technology stack. Moreover, development frameworks like the SAP Cloud Application Framework (CAP, for Java and JavaScript) and RESTful ABAP Programming Model (for SAP BTP ABAP environment), enhanced with GenAI-based code assistance (currently available for CAP, planned for SAP BTP ABAP environment), boost developer productivity and facilitate quick implementation cycles. To get started with creating side-by-side extensions using SAP BTP, the SAP BTP Guidance Framework is an excellent resource.

2. Integration

For smooth end-to-end business process execution, integrating various IT solution components is a technical necessity. Using a Clean Core approach, these integrations use the standard integration scenarios that SAP provides. These scenarios are designed to map comprehensive business processes using pre-configured best practice content, leveraging modern integration technologies like OData, SOAP, or events. Opting for SAP's standard integrations brings several benefits to an organization:

straightforward, out-of-the-box use of the integration, along with continuous updates and innovations.
simplified system upgrades within the integrated landscape, as standard integrations ensure compatibility and maintain consistency across systems.
reduced Total Cost of Ownership (TCO) for managing integrations.

Adopting a Clean Core strategy means organizations should base their custom integration needs on SAP's standard integration scenarios and APIs. Whether it's using SAP's standard integrations or creating custom integrations, the SAP Integration Suite Service on the SAP Business Technology Platform is the recommended tool. You can find documentation for all standard content for the SAP BTP Integration Suite in the SAP Business Accelerator Hub. If organizations need help crafting a corporate integration strategy, the SAP Integration Solution Advisory Method (ISA-M) is there to assist.

3. Data

In today's digital world, data stands as a crucial asset for companies, driving decision-making, strategic planning, and enhancing operational effectiveness. The value of data hinges on its quality, relevance, and semantic description in form of metadata. Here, the Clean Core strategy becomes vital, emphasizing Data Quality and Data Volume/ Data Relevance, which are key to smooth daily operations within the SAP system landscape. The aim of the Clean Core strategy is to ensure that all business and system-related data is consistently accurate, complete, relevant, and accessible. Tools like SAP Master Data Governance can aid in creating a unified master data management approach across various domains to enhance data accuracy. Additionally, SAP Datasphere plays a role in simplifying the data landscape, facilitating access to data across hybrid and cloud environments and utilizing existing SAP BW models. SAP Datasphere keeps the semantic and associations of SAP data intact, which shows the data in its business context. This is important because it makes sure the data is reliable and precise, which helps with making decisions and planning strategies. Integrated with SAP Analytics Cloud, this approach enables informed business decisions based on operational SAP data.

4. Business Processes

Organizations depend on structured business processes for their daily operations, management, and strategic planning. These processes can intersect with various IT systems and sometimes require manual intervention. Streamlining these processes and boosting automation can help organizations reduce unnecessary steps and save resources, leading to improved efficiency and quality. The Clean Core approach focuses on maximizing the use of standard SAP functionalities to maintain consistency and simplicity. It sets out a number of principles for developing clean and effective process designs, such as:

Utilize SAP's standard solutions, Industry Cloud, and certified SAP Partner solutions to align closely with established standards.
Extend SAP's standard solutions for unique, differentiating processes to gain a competitive edge, using tools like SAP Build Process Automation or SAP BTP side-by-side extensibility projects
Continuously evaluate the efficiency of business processes through Process Performance Indicators (PPIs), with tools like SAP Signavio for enhanced analysis which integrates with SAP Build Process Automation.
Automate manual process tasks and improve paper- or email-based, loosely organized processes using SAP Build Process Automation.

In addition to these principles, adopting an Enterprise Architecture (EA) methodology is crucial for ensuring business processes align with an organization's goals and strategy. EA methodologies provide a systematic way to analyze and design business processes and their technology interactions, leading to improved operational efficiency by pinpointing and eliminating redundancies and better allocating resources. Tools such as SAP LeanIX and SAP Reference Business Architecture content, including Solution Value Flow Diagrams and Solution Component Diagrams available in the SAP Business Accelerator Hub, are instrumental in this endeavor, offering valuable guidance for streamlined process design and implementation.

5. Operations

In the context of Clean Core dimensions, operational management can be categorized into two primary objectives: "cleaning the core" and "maintaining the core’s cleanliness." When dealing with a brownfield implementation, "cleaning the core" entails a thorough review of custom code to decide whether it should be phased out, reworked, or updated. This initiative also includes revamping development guidelines and embracing industry-standard practices. Meanwhile, "maintaining the core’s cleanliness" in the aftermath of a successful migration, or when initiating a greenfield project, calls for embedding monitoring and alert systems into the daily operations framework to safeguard the integrity of the core. To accomplish this, a detailed understanding of all the critical performance indicators (KPIs) that influence the Clean Core is necessary, focusing on four key areas: Integration, Extensibility, Processes, and Data. For effective operational management, SAP Cloud ALM serves as an ideal platform. It offers integrated monitoring and alerting capabilities, aligning with SAP’s recommended best practices for operations management.

Summary

SAP Clean Core Strategy is not a one-size-fits-all solution, but a tailored approach that depends on your specific business needs, challenges, and opportunities. The exact path to a Clean Core will vary depending on whether you're starting fresh (Greenfield) or upgrading existing systems (Brownfield), as well as whether you're aiming for a Private Cloud, Public Cloud, or a hybrid setup. However, there are some shared steps to consider for a smooth implementation:

Evaluate your current IT environment to pinpoint challenges and deficiencies: It's essential to gain a clear understanding of your existing IT framework, encompassing systems, processes, data, and integration points. Recognize the issues and deficiencies that are obstacles to your business's transformation, such as complexity, inefficiency, inconsistency, fragmentation, and outdated technology.
Set out your business transformation goals and determine what takes precedence: Clarify your vision for business transformation, including the objectives and desired outcomes, which should reflect your overall business strategy and customer expectations. Determine which initiatives should be tackled first, considering their potential business impact and urgency, and make sure your stakeholders and sponsors agree with your transformation plan.
Craft your desired IT architecture and plan, focusing on SAP S/4HANA and cloud-based solutions: Design a future IT architecture with SAP S/4HANA as the digital core, supplemented by cloud solutions for specific business functionalities. Develop a roadmap that transitions from your current to your desired IT architecture, detailing the project's scope, schedule, and required resources. For this, the SAP Enterprise Support Value Maps can help.
Carry out your transformation project with support from SAP and its partners, utilizing the best practices and methodologies they provide. Manage the change and associated risks carefully, ensuring the quality and security of your IT solutions throughout the process.
Keep track of your transformation's results and benefits: Monitor the outcomes and benefits of your transformation, using the key performance indicators and metrics established in your objectives. Continuously review and refine your IT solutions based on feedback and the insights gained, striving for ongoing enhancement of business efficiency and customer satisfaction.

Previous Blogs:

Blog 1: The Central Role of Clean Core and AI
Blog 2: The Role of BTP as Extention and Innovation Platform

Additional Videos:

Unleash your Digital Transformation with Clean Core : https://youtu.be/i7Ms4WciM9Y
Clean Core in Detail: https://youtu.be/JaSQbFypIkQ

Deep Dive into SAP Build Process Automation with SAP S/4HANA Cloud Public Edition - Retail

2024-03-28T14:19:12.526000+01:00

This blog is intended to complement my previous blogs on automation and augment Retail scenario with SAP S/4HANA Cloud Public Edition as described with available scope items for Retail and SAP Help documentation.

Customers are eager to take charge and explore potential avenues for innovation, aiming to streamline enterprise automation across diverse landscapes. This proactive approach empowers companies to address the challenges of disjointed processes, ensuring they focus their automation efforts where they're most needed.

A Retail company striving to revolutionize its operations, particularly in managing the intricate logistics of end-to-end retail processes. They seek to seamlessly integrate sales from both backyard distribution channels and physical storefronts, even when inventory might not be stored on-site. This pursuit of efficiency reflects their commitment to enhancing customer experience and staying ahead in a competitive market.

Let's explore a typical business situation where sales happen in stores using cash registers (POS systems). These sales involve things like selling items, customers paying for orders, and handling money transactions. To keep track of all this, we need to automatically create documents showing when goods leave the store, including steps like gathering items, putting them in packages, and officially marking them as sold and out of the store.

Real-time stock levels are monitored within SAP Customer Checkout Manager for immediate visibility. Data is moved from S/4HANA Public Cloud Retail to SAP Customer Checkout Manager, focusing on master data replication. Financial and sales transactions flow from SAP Customer Checkout Manager back to S/4HANA Public Cloud Retail. Learn more about Integration of SAP Customer Checkout Manager with S/4 Public Cloud Retail with documentation.

Executing enterprise automation with SAP Build Process Automation / SAP Integration Suite Middleware using SAP Event Mesh with business events, help trigger fully automated process. Customer can set up their custom enterprise automation bots and workflows by leveraging and extending the available best practices content on SAP Bot Store. Ex. documents for goods movements such as outbound delivery, Picking, Packing and Post Goods Issue need to be automatically accomplished. You can learn more with documentation.

SAP Event Mesh is a fully managed cloud service running on SAP BTP for enabling applications, integrations, and extensions to communicate asynchronously through events. It is part of SAP’s event driven ecosystem and powers end-to-end event driven architectures. SAP Event Mesh allows applications to communicate through asynchronous events.

Experience greater agility and scalability when you create responsive applications that work independently and participate in event-driven business processes across your business ecosystem. Learn more with SAP Help | Documentation

Currently all public business events for SAP S/4HANA Cloud listed on Business Accelerator Hub are supported and can be used to streamline the process with automation.

Customers envision to have AI-powered SAP Build Process Automation solution to integrate applications such as SAP S/4HANA Cloud Public Edition with their point-of-sale (POS) system, discover process inefficiencies and automate business processes.

SAP Build Process Automation provide the flexibility for the customer to automate across the enterprise to improve efficiency and reduce errors, along with Event Mesh set up. Event-Broker-as-a-Service decouples communication between event sources and event consumers in a plug-and-play fashion.

Streamline Goods Movement and Posting Billing Document
Extend pre-build Template packages to customize and perform automation using Business Events

Customer vision is to have real time business updates on significant changes in business applications for their logistics and Retail sales process, throughout their business ecosystem and increase flexibility and scalability by loosely coupling business applications and infrastructure.

Automated Goods Movement and Posting Updated Billing Document using SAP Build Process Automation

Utilizing automation through the API API_MATERIAL_DOCUMENT, the system orchestrates the creation of postings to maintain a seamless availability of articles on the storefront. Additionally, it initiates the generation of material documents following a trigger event at the Event Mesh, occurring subsequent after the creation of a point-of-sale (POS) receipt.

Within the Event Mesh framework, occurrences related to material documents are captured. These events manifest when a material document is generated (MaterialDocument.Created.v1) or when an item within a material document is canceled (MaterialDocument.Canceled.v1). Further insights into Material Document Events can be obtained for deeper understanding with SAP Help | Documentation

Furthermore, the allocation of specific delivery groups to outbound deliveries is imperative using SAP Build Process Automation BOT. This ensures that the requisite shipment resources are appropriately assigned to undertake subsequent outbound delivery tasks. The assignment of outbound delivery groups is managed externally to the cloud ERP system, documented within a spreadsheet, and synchronized with the SAP S/4HANA Cloud, Public Edition for updates and maintenance.

SAP Build Process Automation helps automatic creation of Picking and Packing, goods issue and monitor process using process visibility. Notification events or data events can be sent from the event source to inform of the change. Message holding the event description in an encoded format is sent through an event broker, where event consumers have registered with the event broker and are informed of the event.

SAP Build Process Automation best practices content extended to update the delivery group for outbound deliveries assignment.

SAP Build Process Automation perform automated goods movement tasks such as Picking, Packing and Goods Issue.

SAP Build Process Automation helps updating the billing document for sales for with specific attributes, Proof of Delivery, reference point-of-sale (POS) number, as well as the respective financial postings in SAP S/4HANA Cloud.

For Retail business scenario, solution leverage Store Connectivity POS Outbound (3I2) to send the (Articles, B2C prices etc.) information from SAP S/4HANA Cloud system to point-of-sale (POS) system.

POS outbound service operation enables you to send product master data, sales price information, and additional information, such as purchase price information and bills of material, to point-of-sale (POS) systems. You can learn more with Documentation | SAP Help Portal and API Documentation

For Retail business inbound scenario, solution leverage POS Inbound (3HV) functionality to transfer information from POS Sales receipt and means of payment for articles available at Store front and backyard distribution channel.

In addition, configuration set up can be done to transfers aggregated sales, aggregated payment list, sales per receipt and returns, and customer order payment information by creating material and billing documents in SAP S/4HANA Cloud system.

"POS Sales Transactions - Create" inbound asynchronous service to replicate POS sales transactions in SAP S/4HANA Cloud system. You can learn more with SAP Help Finance Transactions. Documentation | SAP Help Portal

POS Sales Transaction - Receive Confirmation outbound service enables you to receive a confirmation as soon as you successfully posted a POS sales transaction in the SAP S/4HANA Cloud system. Documentation | SAP Help Portal

"POS Financial Transactions - Create" inbound asynchronous service enables you to replicate point-of-sale (POS) financial transactional data to SAP S/4HANA Cloud system. You can learn more with SAP Help Finance Transactions Documentation | SAP Help Portal

POS Financial Transaction - Receive Confirmation outbound service enables you to receive a SOAP confirmation as soon as you successfully posted a POS financial transaction in the SAP S/4HANA Cloud. Documentation | SAP Help Portal

POS Inbound (3HV) create billing Document for sales and means of payment. Billing Document Events are triggered and received by Event Mesh that informs a external system about created, changed, and canceled billing documents in an SAP S/4HANA Cloud. Event mesh will have automated execution for SAP Build process automation bot that reads the billing information via API based bot (https://api.sap.com/api/API_BILLING_DOCUMENT_SRV/overview) and send it to POS system.

In general, SAP recommend using the SAP Omnichannel Sales Transfer and Audit solution which can be further evaluated in the given scenario. This solution will further optimize by having aggregated transactions (and, in specific use cases, nonaggregate (receipt-level) transactions) are periodically pushed to the back end for further processing.

Let’s take a deeper look at technical configuration steps using Event Mesh with SAP S/4HANA Cloud, Public Edition with 10 simple steps that can get your event driven automation up and running.

Setup Connectivity and Extensibility

You can set up the connectivity between Event Mesh and the SAP S/4HANA Cloud Public Edition Tenant that enable the exchange of credentials between the two systems. Administrator should first create an SAP S/4HANA Cloud Extensibility service instance with service plan messaging. Learn more with documentation.

Maintain Extensions on SAP BTP - To build extension applications for your SAP S/4HANA Cloud system, you need to connect your SAP S/4HANA Cloud system to your SAP Business Technology Platform global account. SAP Business Technology Platform Cockpit, open your global account and choose Systems - Add System. Learn more with Documentation | SAP Help Portal
Set Up Entitlements for Your Subaccount Documentation | SAP Help Portal
Set up your subaccount entitlement for SAP Event Mesh - Click on Configure Entitlements and then on Add Service Plan. In the Subaccount Entitlements dialog box, select the service Event Mesh. In the Service Details: Event Mesh screen area, check both options the default service plan and the Standard (Application) and then click on Add Service Plans.

Messaging to consume SAP S/4HANA Cloud events and create event-based extensions using the event bus from SAP Event Mesh and api-access for generic access to SAP S/4HANA Cloud APIs.

Navigate to SAP S/4HANA Cloud Public Edition Home -> Communication Management tab and choose the tile Maintain Extensions on SAP BTP.

On the Maintain Extensions on SAP BTP screen in the Integration section, choose New.

In the Integration Token field, paste in the integration token generated and copied from the SAP Business Technology Platform. Enter a description for your system integration token and save it.

Both Services will be displayed in the list of entity assignments.

3. Navigate to your BTP subaccount and allow SAP Business Technology Platform applications to consume events and APIs from SAP S/4HANA Cloud, you need to create the relevant service instances of SAP S/4HANA Cloud Extensibility for the service plans api-access and messaging.

Inside the subaccount. Select in the left menu Services -> Instances and Subscriptions. Then Click on the button “Create”.

4. In the screen for create wizard the available Services will be displayed in the Plan dropdown list, select the service SAP S/4HANA Cloud Extensibility with plan messaging.

5. In Runtime select Cloud Foundry. Then choose the space created, for this example “dev”, then the systems linked to the BTP are displayed in the list, here choose the S4HANA Cloud to be extended “XXX”. Choose a CLI name "XXX-SBPAEvents" for your instance (e.g. XXX-SBPAEvents). And click Next.

The next screen for parameters request the Client Id with 4 chars and the system name. then click Next

6. Create a new service. Inside the subaccount. Select in the left menu Services -> Instances and Subscriptions. Then Click on the button “Create”.

7. In the Create wizard in the Service dropdown list, select the service SAP S/4HANA Cloud Extensibility. Select the Service Plan api-access, ex. "XXX-SBPAEventAPI" which you use for generic access to APIs in your SAP S/4HANA Cloud system. The communication arrangement A2X_OD_0106 is created in SAP S/4HANA Cloud, Public Edition using scenario SAP_COM_0106

After the creation of the service, you can check the automatic creation of the communication arrangement in SAP S/4HANA Cloud, Public Edition system. Navigate to Communication Arrangements and look for A2X_OD_0106.

8. Navigate to SAP S/4HANA Cloud Public Edition - Enterprise Event Enablement - Configure Channel Binding, Select your event channel from the list SAP_CP_XF_XXX

In the new screen, click Create over “Outbound Topic Bindings” section. Select the Topic that will be used for the event. Then you can create the topic. The topics will appear in the list.

9. Navigate to SAP BTP Tenant. Create a new service (Event Mesh).

Inside the subaccount. Select in the left menu Services -> Instances and Subscriptions. Then Click on the button “Create”.

Search for Service “Event Mesh”, Plan “default”, Run Environment “Cloud Foundry”, choose the space in Cloud Foundry, and the name for the instanceSBPAEventMesh and click , Create Event Mesh Instance

To manage the Event Mesh Instance, create a new service for Event Mesh now for Standard Plan. Inside the subaccount. Select in the left menu Services -> Instances and Subscriptions. Then Click on the button “Create”.

Search for Service “Event Mesh”, Plan “Standard” and click Next

10. Navigate to BTP Sub Account and access the Event Mesh Cockpit, you need to subscribe to SAP Event Mesh and assign several roles to your user. Go to option Security -> Roles. Now create the role ex. "Event Custom Roles".

Now your " Event Mesh" Application is ready to be executed that will capture events triggered from SAP S/4HANA Cloud, Public Edition System.

You can jumpstart automation projects with hundreds process content packages available in public bot store, SAP Build Process Automation bots and connectors designed specifically to enhance the capabilities of your SAP applications.

SAP Build process automation connectors, create Actions to communicate with external systems or leverage Automation SDK providing different activities for an automation.

Stay tuned for more updates in the next quarters!

Where to Find More Information:

Watch the replays of our exclusive SAP S/4HANA Cloud Public Edition 2402 Early Release Series here: https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/watch-the-replays-of-our-excl...
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
Find out how to switch from groups to spaces and pages here: https://blogs.sap.com/2023/11/06/deactivation-of-groups-in-the-sap-fiori-launchpad-in-sap-s-4hana-cl...
Become an early adopter for Joule in SAP S/4HANA Cloud Public Edition here: https://influence.sap.com/sap/ino/#campaign/3612
Check out the SAP Activate Roadmap for early adopters here: https://go.support.sap.com/roadmapviewer/#/group/658F507A-D6F5-4B78-9EE1-0300C5F1E40F/roadmapOvervie...
Review the PPL content here: https://go.support.sap.com/roadmapviewer/#/group/658F507A-D6F5-4B78-9EE1-0300C5F1E40F/roadmapContent...
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

Exploring SAP Extensibility - Types of Extensibilities

2024-04-02T22:28:55.301000+02:00

In this blog post, I will give a brief explanation of the types of extensibilities offered by SAP: Key User (In-App) Extensibility, Developer (On-Stack) Extensibility, and Side-by-Side Extensibility on SAP Business Technology Platform (BTP). The intention is to provide just a brief summary for each type of extensibility available.

Firstly, why is extensibility necessary? Despite SAP offering numerous standard solutions, there are instances where these solutions fail to align with the unique requirements of a client's business logic. Consequently, there is the necessity to customize the standard solutions provided by SAP to fulfill these specific requirements.

Key User (In-App) Extensibility:

Functionality: This extensibility type allows the customization of SAP Fiori apps, add application logic, create custom fields, expose data, develop custom forms, email templates, analytics, and business objects mostly without a single line of code.
Targets: It is aimed at business users responsible for configuring and customizing SAP systems.
Development Tools: SAP Fiori apps, Business Add-Ins (BAdIs), Core Data Services (CDS), SAP BAS, and SAP BTP.
Technical Implementation: Key users can modify existing Fiori apps, integrate custom logic through BAdIs, extend standard business objects, generate custom CDS views and APIs, customize forms and email templates and develop custom analytics using CDS views.

Here's a video showing some examples of In-App Extensions: https://www.youtube.com/watch?v=pOOORn7fIR0

Here’s a scenario example of a Key User Extensibility: https://extensibilityexplorer.cfapps.eu10.hana.ondemand.com/ExtensibilityExplorer/#/ExtScenario/351

If you would like to implement this scenario you can follow this setup guide: https://help.sap.com/docs/SAP_EXTENSIBILITY_EXPLORER/397bf26514884cc8a5ece65970e8e3e6/3f898d6f59254ef497f00c78423cec7a.html

Developer (On-Stack) Extensibility:

Functionality: This extensibility provides flexibility to extend standard processes, develop custom OData services, and build custom APIs while isolating custom code from the digital core.
Targets: It is aimed at ABAP developers.
Development Tools: ABAP Development Tools in Eclipse and SAP Business Application Studio (BAS).
Technical Implementation: Developers can utilize ABAP RESTful application programming model, CDS views, released DDIC objects, and local APIs to extend standard processes and develop custom services.

Image Source: https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/sap-s-4hana-extensibility-simplified-guide-for-beginners/ba-p/13548988

Here’s a scenario example of a Developer Extensibility: https://extensibilityexplorer.cfapps.eu10.hana.ondemand.com/ExtensibilityExplorer/#/ExtScenario/2851

If you would like to implement this scenario you can follow this setup guide: https://help.sap.com/docs/SAP_EXTENSIBILITY_EXPLORER/c87ef8f108e147d6b7143fd3c0fb1459/5d131ae128ed4b4fae521dc3bf798c88.html

Here’s a quick explanation and examples of RAP Extensibility: https://www.youtube.com/watch?v=YNOa1c0BxR0

Side-by-Side Extensibility on SAP BTP:

Functionality: SAP BTP serves as a unified platform for extending both cloud-based and on-premises SAP solutions, offering integration capabilities at various levels.
Targets: It is suitable for JavaScript, Java developers with cloud-native expertise, and ABAP developers.
Development Tools: Cloud-native tools and services provided by SAP BTP, such as SAP CAP, SAP Fiori tools, and SAP BAS.
Technical Implementation: Implemented using cloud-native technologies and services within SAP BTP.

Image Source: https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/sap-s-4hana-extensibility-simplified-guide-for-beginners/ba-p/13548988

Here’s a scenario example of a side-by-side extensibility: https://extensibilityexplorer.cfapps.eu10.hana.ondemand.com/ExtensibilityExplorer/#/ExtScenario/310

If you would like to implement this scenario you can follow this setup guide: https://help.sap.com/docs/SAP_EXTENSIBILITY_EXPLORER/b0e8d558ba2f47f5b02a3fc0ac9edc34/c9520e9b67dc4d04bdae124f46c23bff.html

Developer (On-Stack) Extensibility VS Side-by-Side Extensibility on SAP BTP:

In summary the Developer (On-Stack) Extensibility is ideal for extending standard SAP processes and functionalities within SAP S/4HANA, maintaining tight integration with the digital core while the Side-by-Side Extensibility on SAP BTP is suited for developing independent applications or extensions that enhance and extend the capabilities of SAP solutions, enabling agility and innovation in addressing specific business needs.

Conclusion: SAP's extensibility options provide organizations with the flexibility and scalability needed to adapt their ERP solutions to evolving business requirements. Whether it's extending standard SAP processes within SAP S/4HANA or developing standalone applications on SAP BTP, businesses can leverage these extensibility capabilities to drive agility, innovation, and growth in today's dynamic business landscape. I hope that with this blog you now have a more clear understanding of the different type of extensibilities there are and which ones your work assigns to.

If you want to have a more detailed vision of SAP Extensibility read this blog from @Raja - https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/sap-s-4hana-extensibility-simplified-guide-for-beginners/ba-p/13548988 (Thank you @PedroLopes for the share).

SAP S/4HANA Cloud Extensions with SAP Build Best Practices: An Expert Roundtable

2024-04-03T01:57:48.422000+02:00

In this blog adapted from the podcast “SAP S/4HANA Cloud Extensions with SAP Build Best Practices: An Expert Roundtable”, SAP experts discuss SAP S/4HANA extensibility best practises and SAP Build.

Vanessa Micelli-Schmidt, Chief Product Expert, SAP Build
Felix Wente, Chief Development Architect, SAP S/4HANA
Mark Wright, Director, Marketing and Solutions, SAP Build Code
Host: Terry Penner, Marketing and Solutions, SAP BTP

Let's Talk Cloud ERP Podcast

Key products covered:

SAP Build Code at sap.com/build-code
SAP BTP for RISE at sap.com/btp-for-s4hana
RISE with SAP

Topics discussed:
Part 1: Introduction to S/4HANA Cloud Extensions Best Practises

What is Clean Core
Extensibility Options and Best Practises for S/4HANA Cloud Private Edition customers
Advantages and disadvantages of on-stack vs using BTP tools
Extensibility changes for S/4HANA over the past few years.
Best practices for UI-focused applications and mobile services with SAP S/4HANA

Part 2: SAP Build Code for SAP S/4HANA developers

What is AI bringing to the table for S/4HANA implementers and developers
Build Code scenarios for developers who are using Business Application Studio right now
Build Code roadmap plans to help developers work more easily with S/4HANA
How S/4HANA developers can improve governance
Pragmatic recommendations for the type of extensions developers should create

Part 1: Introduction to S/4HANA Cloud Extensions Best Practises

Terry: To start our discussion, please describe what "Clean Core" means to you and why is it important to S/4HANA Cloud Private Edition customers in particular.

Felix: I think it can be best explained if you look directly at each of the words. The term “core” in ERP systems primarily refers to extensibility, processes, data quality, integration, and operational capabilities. These features depend on the specific software stack implemented by the customer. The concept of "clean" refers to the quality of how this core is adapted by customers and partners, focusing on up-to-date extensions, transparency, an unmodified and consistent core, and efficient, cloud-compliant operations.

The main advantage is agility, which allows you to benefit from innovations in a quick, straightforward manner. This includes consuming updates and upgrades without being disrupted by large adaptation projects, which can be hard to plan especially if you have extensive modifications. Ultimately, you save effort in extensibility and testing, reducing the Total Cost of Ownership (TCO). Furthermore, when it comes to data quality, you can more easily turn your data into value, resulting in more reliable forecasts and precise predictions

Terry: What are some key customer challenges you’ve experienced around extensibility and clean core?

Vanessa: Sometimes, customers are unaware of the full capabilities of SAP's developer portfolio. Depending on the skill level of their developers, ranging from professional coders to low coders or key users, fusion development scenarios can be utilized to create robust applications or process extensions, maintaining a clean core. This brings numerous benefits as mentioned earlier by Felix.

However, when discussing our extension development portfolio, customers can find it challenging to determine the appropriate tool for a specific use case. Despite the increasing integration among our tools, the use case might dictate the choice of tool. Therefore, I always recommend conducting a thorough use case evaluation.

Before starting to implement something, it's crucial to ask key questions: Is it a typical low-code use case? Are key users available who can reduce some of the burden from your IT by using SAP Build tools? Or, do you want to quickly create template-based SAP Fiori applications and have someone who prefers working in a pro-code environment? Then use SAP Build Code. Determining the types of personas who will be available to work on the solution should be an integral part of the decision-making process on which tool to use while maintaining a clean core.

Mark: Vanessa mentioned the importance of tooling. I'm from the app development side, so I hear a lot about extending beyond S/4HANA. Business acceleration is driven by making data available to end users. SAP is a leader in providing business-relevant data, but we can't rely solely on it. We see many customers wanting to run applications across various business networks. This presents a challenge for developers who need to interact with both SAP and third-party systems.

So, we're creating a landscape for side-by-side extensibility that encompasses both SAP and non-SAP systems. While we are leaders in SAP applications, it's crucial to also focus on integrating non-SAP systems. This is where tools like build apps, build code, and enterprise automation, which we provide in BTP, come in handy for our customers.

Terry: Can you share with us some examples of best practices for extending data tables or standard functionality.

Felix: If you're looking to extend S/4HANA on stack, which refers to directly integrating within the system where the software operates, we offer two tool infrastructures tailored for key users and developers.

For key users, the primary focus is on customizing user interfaces, which includes adding custom fields, implementing basic custom logic like checks or calculations, creating mini applications, designing custom views, and configuring analytical queries. This customization is managed within a wizard-like environment, launched directly from the S/4HANA applications. As a key user, you can navigate these features without needing a comprehensive understanding of the technical aspects of the data model.

With developer extensibility you can build complex extensions beyond what a key user can accomplish. You can also expose local software artifacts as remote APIs if you want to build on BTP. However, it's crucial to adhere to SAP's public APIs, both local and remote, that are explicitly labeled as public. By doing so, you maintain compliance with the clean core approach, and your software artifacts remain stable, ensuring that your code won't require adaptation after an upgrade in the private cloud. This means you can continue using your existing extensions.

In the private cloud, you can still use your existing extensions, we call this “classic extensibility”. This concept mainly applies to brown-field code that already operates within system landscapes. Despite this, it's possible to enhance compliance with the clean core, and we recommend using a set of stable legacy APIs, primarily BAPIs. These can be wrapped in your custom code and adapted in the public cloud, similar to future APIs.

We refer to this as the "three tier approach." If you're interested in learning more, we'll provide links to guidance documents, papers, and blogs.

Terry: What are your most important best practices for working with SAP Build on SAP S/4HANA?

Mark: Felix discussed the on-stack and key user capabilities essential for maintaining a clean core. When I address best practices, it's usually about the use of side-by-side extensions to continue preserving your clean core by implementing solutions on a platform. We refer to our platform as the Business Technology Platform (BTP), a truly innovative differentiator within SAP.

We aim to build cloud-native applications and maximize productivity on this platform. We provide a variety of frameworks, languages, libraries, and tools. These are based on two different types of modeling capabilities: the Cloud Application Programming (CAP) model and the Restful Application Programming (RAP) model.

Our developers often use CAP when developing and extending data tables if they're Java or Node.js developers. SAP developers who prefer ABAP typically use RAP. Both can be used effectively to model domains, create service definitions, and extend standard functionality. These tools are solutions provided on BTP, which make it easier for developers to create CAP models using a graphic data modeler. We also offer data backend visual cloud functions and build apps. All these processes are driven through AI and integration, forming our best practices. This allows us to leverage different programming models efficiently.

Terry: What would you say are the advantages and disadvantages of on-stack vs using BTP tools?

Felix: On-stack extensibility offers the advantage of a close connection between SAP applications and customer extensions, enabling extension of the business logic within a transactional context. This provides deep integration into our processes, allows for the enhancement of SAP data schemes, and offers benefits such as Data Neighborhood in analytical scenarios.

However, the same tight coupling is also a disadvantage. Even though On-Stack Extensions comply with the clean core, they don't scale beyond the user group of the ERP system in operation. For example, if you want to engage with third-party customers like contractors, you might not want to grant them access to your system, as the coupling could be too tight.

Furthermore, on-stack extensions are specifically for enhanced stacks and may not be the best option for larger, self-contained applications or hub scenarios. Finally, this approach might not align with your preferred software stack or programming language.

Vanessa: As Felix pointed out, you might select side-by-side extensibility on BTP when you want to avoid tight coupling. This is when you prefer to separate your extensions from S/4HANA and BTP and loosely link them using methods like remote API calls or events.

You'd also choose this approach when your extension isn't available in the on-stack extensibility, as Felix stated, or when it's a hub scenario. In other words, when you wish to integrate with multiple S/4HANA systems, other SAP solutions, or cloud services. The SAP Build option also offers the potential to automate S/4HANA processes across different systems, providing another situation where side-by-side extensibility might be needed.

When discussing Build, it's worth noting the interoperability between low and pro-code tools. We see the use of tools in so called fusion teams in a fusion development setting. This allows more people with varied skillsets within your organization to contribute to the extensibility story. This way, you can leverage innovations from a wider range of enterprise employees and involve more experts in your enterprise's innovation process.

Fig.1 SAP S/4HANA Extensions

Terry: What has changed with extensibility for S/4HANA over the past few years?

Vanessa: I don't see a shift in the scenarios, and perhaps Mark and Felix could add their input. I do, however, observe a change in the workforce and the tools they want and can utilize. The industry-wide challenge we're seeing, which likely resonates with our listeners, is a talent gap coupled with growing demands on IT departments. Unfortunately, these departments are not growing at the same rate. The common solution sought is simplifying development processes and boosting developer productivity.

Our approach to this issue is reflected in our product design. We previously mentioned AI, which is one avenue for enhancement. For example, our tools can be augmented with AI, such as in the case of Build Code where data models can be created using natural language. AI also soon allows processes to be described in natural language for auto-creation or support in creating in SAP Build.

Another strategy is to expand the range of developers, allowing key users to share in the development burden. This integration of multidisciplinary teams into the development process can lead to powerful fusion development scenarios. Complex solutions can be created collectively, with IT professionals providing oversight or backend creation for specific extensions, following predefined guidelines.

Felix: I want to emphasize that our goals of extensibility have remained consistent. From the outset, our primary aim has been to comply with a clean core, with a focus on extensibility. To this end, we've developed APIs and other software artifacts that we've maintained stably.

However, while our core principles have remained unchanged, our tools have continuously improved. With each release, you can expect to find new features, increased power, and more public APIs. We're also providing more stable points for extending business logic.

One new offering is our developer extensibility of the ABAP Cloud approach. This new feature enables a more complex form of extensibility.

Mark: Building on what Felix and Vanessa mentioned, clean core is not a new concept. What we have done is simplify the process of achieving clean core. While we have been discussing it for over a year, we haven't always made the process easy.

In the past, not all APIs were available, and integrating with side-by-side extensibility solutions was challenging. Now, we're making it easier for SAP developers to stay within SAP. You don't need third-party tools to achieve a clean core.

We're offering solutions like BTP build apps, build code, and an integration suite to simplify the development of clean core with side-by-side extensions and even on stack. This makes it easier than ever to achieve clean core, and you can do it entirely with SAP.

Terry: What best practices do you recommend for UI-focused applications and mobile services with SAP S/4HANA?

Vanessa: My recommendation will vary based on the type of workforce you have. Let's assume you have business experts who not only have specific requirements but are also trained as citizen developers or key users. They could then create a pixel-perfect user interface (UI) in SAP Build Apps, be it a web app or a mobile UI, depending on their needs. Within this low-code environment, they could easily connect to a backend system provided by a developer, for example, in Build Code. I’ll hand over to Mark to share his recommendations for a workforce that prefers to operate solely in a professional development environment.

Mark: Vanessa and I, along with our colleagues, discuss fusion development often. The focus is on creating applications that are, as Vanessa describes, picture perfect. We connect these apps to S/4, but the emphasis lies on adhering to best practices enabled by Build Code.

Internally, we refer to these application frameworks as the Golden Path. We strongly encourage our customers to follow these best practices to develop future-proof applications. Build Code offers design and runtime capabilities, allowing the creation of UI applications.

These applications can be developed with AI using Joule CoPilot and can include data models. They can integrate with SAP and third-party systems through the service center. Best practices for UI development involve UI5, Fiori elements and mobile services.

Fusion development is useful for backend consumption, while the frontend is built with Build apps. We sometimes integrate with enterprise automation flows to allow seamless creation of UI applications. This extends your S/4 environment not just to mobile, but also to web applications.

Part 2: SAP Build Code for SAP S/4HANA developers

Terry: AI is a hot topic right now, what is artificial intelligence bringing to the table for S/4HANA implementers and developers?

Felix: We have ongoing projects aimed at our user groups, such as developers, who we believe will benefit from AI-generated code. This could be particularly useful when programming against S/4HANA, or when building applications, as AI can efficiently create a running skeleton of code.

For key users, we're developing AI assistance in planning and development with the goal of enhancing extensibility. While key users can currently extend an SAP application directly from its user interface or UI, the application's data can also be used in a broader business process. This might involve follow-up activities like using extensions, creating print forms and email templates, and developing analytical reports.

If a key user doesn't easily anticipate all these possibilities, an AI assistant can help define their goals more precisely and streamline the process of creating key user extensions.

Mark: We're truly excited about Build Code. This solution incorporates generative AI through SAP Joule CoPilot. By providing natural language prompts to Joule, you gain the ability to create CAP-based applications. Adhering to best practices for extending your S/4 backend, the Build Code solution creates these applications, complete with data models, OData services, sample data, application logic, unit tests, and even UI extension through generative AI.

This essentially establishes a solid foundation for application extension, leading to increased developer productivity and faster time-to-market for applications. My expertise lies in using generative AI within Build Code.

Beyond Build Code, SAP offers a wealth of AI capabilities with our AI core or AI foundation and S4. Developers looking to extend S/4 can leverage these AI capabilities.

Terry: Help me understand what Build Code means for developers who are using Business Application Studio right now to create applications.

Mark: Build Code is just an evolution. Business Application Studio, our web-based IDE for BTP development, offers guided templates and a service center for integration with your S/4 backend and other environments. It's designed to help developers follow SAP's best practices. We've now integrated Business Application Studio (BAS) into Build Code, SAP's development environment. Here, developers can experience embedded AI with Joule, and we'll keep innovating within Build Code.

Developers aren't losing anything by transitioning to Build Code. It's easy to use just the development environment without committing to all of Build Code's capabilities. By switching, developers can benefit more from Build Code's features like DevOps, lifecycle management, and design capabilities, all in a single solution.

Remember, Business Application Studio remains available for current users, but we'll be focusing on further innovations within Build Code moving forward.

Terry: What is planned in the Build Code roadmap that will help me work more easily with S/4HANA

Mark: Build Code is tailored for our professional code developers, offering a turnkey development environment. We're excited about our contributions to both design time and runtime aspects. We plan to enhance and improve the generative AI capabilities, an area many customers are keen to see progress in. We aim to provide this through various capabilities for your OP developers and also by fostering more fusion development capabilities.

Fusion development, a topic Vanessa and I discuss often, is something we aim to expand so that any developer can utilize our build solutions effectively. We're excited about the support we can provide developers in extending the S4 applications. In addition, we want to emphasize that we're working towards seamless interoperability. Our goal is to enable SAP developers to easily develop extensions while maintaining the core integrity of S/4 and build code.

Terry: What are some ways S/4HANA developers can improve governance?

Vanessa: When discussing SAP Build and local development, as well as empowering key users and enterprises, I receive two customer reactions. The first is excitement, as they believe they can now expedite their extension projects, which is indeed possible. However, I also encounter concern revolving around governance, as one customer once asked, "What if everyone in my enterprise starts building applications without control?" This is precisely what we aim to avoid with providing governance tools for low-code development. Additionally, to address this, we offer guardrails, documentation, and have a comprehensive roadmap ahead of us. These guardrails allow organizations, for instance, to determine who qualifies as a citizen developer. You can choose to be either strict or lenient in this regard. For example, you can specify that only individuals with a particular certification are allowed to start building assets. We recommend certifying your key users or citizen developers in order to make them aware of their obligations when they begin building. This is one way to determine who is authorized to build. We also offer ways to define environments, such as allowing key users to create assets with specific data they can access and use in their applications, and do that in a protected (non-productive) environment. We provide a comprehensive set of easy-to-use tools that help effective monitoring and governance. This ensures that people do not go against the rules when creating these extensions.

Terry: Can you give us some pragmatic recommendations for the type of extensions developers should create

Felix: The most important thing to understand is that it's not a matter of either/or. In your system landscape, you will likely have a mix of clean and not-so-clean extensions. For example, in an existing private cloud installation, you may have a lot of existing code that doesn't align with clean core principles. In this case, it's important to be pragmatic and recognize that achieving a clean installation won't happen overnight. It's more of a journey.

During this journey, as you modernize your custom code, it's important to consider the purpose of your extensions and who they are intended for. Ultimately, the best approach may involve a combination of on-stack extensibility and side-by-side extensions for different tools. This will allow you to achieve the flexibility needed to meet your business needs.

[ Note: This blog was adapted from the podcast transcript by an SAP system using Azure OpenAI–gpt-4 ]

Explore other topics in this series:

Custom data as table, CDS, Domain, Business object and all that jazz...

2024-04-05T13:51:06.478000+02:00

The need for custom data is nothing new. But these days we want to do it while keeping our core clean and thus we want to look at Key User and on-stack Developer Extensibility, which give a lot of options. Below I attempt to showcase each option relating to having your own "custom data" in S/4HANA, with some pros and cons and when to use which option. To illustrate the options, I'll be doing a bookshop scenario; my company is a bookshop, I have an S/4HANA system and now I need to extend it.

Custom transactional or master data

If you have a need for custom transactional or master data, I would recommend to first look at Custom Business Objects (App on SAP Fiori Apps Reference Library) or Custom Business Configuration (App ). Meaning, if in the old ways you would have created z-table(s) and then generated SAP GUI sm30 maintenance dialog (or even your own ABAP report for maintenance), then you want to use this.

What's the difference? Custom Business Configuration are meant for customizing tables, rather than actual "objects". Simpler data that often has more simple maintenance. Custom Business Objects are meant to represent an actual object that does not yet exist in the system. In the end, both apps do something similar: generate a BO with CDS views and OData service.

Custom Business Configuration objects have the "advantage" that they don't need their own separate Fiori app (as I explain below) but the data maintenance happens in the Custom Business Configuration app, with a nice and simple Fiori UI, all generated for you. Here is a tutorial which explains such an example step-by-step, so I won't go further into it (the tutorial is for ABAP Environment on BTP but works as well on-stack in your S/4HANA ABAP environment).

Custom Business Objects, as said, lets us create our own "object": meaning data that has more than just 1 field. In the example of the bookshop, authors of books could be such a custom object. Custom Business Objects even lets us create hierarchical objects; say for example we even would like to be able to enter one or more family member of that author, we would not want to do it on the same "level" as the author, but we would have author and then 0 or more family members linked to that author. This is done very easily in Custom Business Objects, as all you need to do is add an extra "Node":

And under "Fields" we enter the needed fields for both nodes:

Important before we publish this, if this is data that needs a "maintenance dialog" or a Fiori app which allows us to create, update, and delete entries for this data, then you want to check under Features "User Interface" if you are on S/4HANA Public Cloud. If not, this option will not be available, and you instead manually check "Back End Service" (which is checked automatically after selecting User Interface for Public Cloud).

As seen above, if we need to add some logic before we want to save data (on update and before save), we can also check "Determination and Validation" (only if we need that).

After publishing, we can write the needed logic (if any at all), we can look at our generated Fiori app, and we can create a tile for it, so we can add it to the Fiori Launchpad of the users needing this app. On Private Cloud or On Premise we have a few extra steps to take; using the generated OData service (its name is listed underneath "Back End Service"), we can generate our own Fiori Elements Application on SAP BTP with Business Application Studio. The con here is of course that we need to do this as an extra step. The pro is that we can fully decide how the UI should look like. Once we are done with the UI, we can deploy the app to our system, generate tile and target mapping for it and assign to users, as per usual practice.

Hopefully you can see here that we get a lot of functionality "out of the box" while using Custom Business Object's simple user interface. We define our fields, have the possibility for hierarchical data and for public cloud we can even generate a whole Fiori app. This option should therefore be considered first, before you go and create your custom z-table(s) in the dictionary. If you do it that way, you are many steps away from a Fiori App and an old-school SM30 maintenance dialog is not clean core.

Here a screenshot of the final app, which I generated via BAS on SAP BTP without needing to change anything on the UI (all done via Fiori Tools wizard):

What if the data needs NO maintenance app?

As I mentioned, Custom Business Object is perfect when we want to replace old z-tables with sm30. But what if we had z-tables that were filled differently? Maybe from an integration or through a BAdI? Well, the answer is "it depends" 😉. When we talk about integration, we can use the generated CDS to create a REST API service that could be used by the integration. If we create z-table(s), we have to do the CDS part manually. If a REST API won't do the trick, consider how you update the data? In the ABAP Cloud programming model, we don't want to MODIFY/UPDATE/INSERT directly into the database, not even z-tables. Instead we use EML or Entity Manipulation Language, for example:

DATA update_tab TYPE TABLE FOR UPDATE /DMO/R_AgencyTP.
update_tab = VALUE #( ( agencyID = '070001' Name = 'MODIFIED Agency' ) ).
MODIFY ENTITIES OF /DMO/R_AgencyTP " name of behavior definition
  ENTITY /DMO/Agency " name of entity to read
  UPDATE FIELDS ( name )
  WITH update_tab.
COMMIT ENTITIES.

So once again, having a CDS generated can actually save time here. But there are cases where we want to be in full control of the CDS RAP object, then we could start from z-tables and work our way all the way to CDS and behavior definitions and create everything manually; takes time but it's powerful and flexible.

Custom "Name-Value" data

If you need a simple field where you have a couple of static values (which don't change often and don't need any maintenance app) with a descriptive text, then in the old days we would create a domain. Today we can still do it with a domain, or we can use "Code Lists" as they are called in the Key User apps. Code Lists are explained in the next chapter and can be created as "reusable", meaning those code lists are used on custom business object, or directly when adding a custom field to a business context. To showcase the example, I created a domain for the bookshop:

Further below I add a custom field "Book Genre" into Product General Data and book genre uses this domain. So, if the domain has no direct end user exposure, it is very fast and easy to keep using. However, if I would have added the field directly onto Product General Data, then a Code List would have been preferable, because the input will be managed with drop-down that can be typed in, rather than having to open a pop-up for search-help and finding the domain values.

Extend Standard Data with Custom Data

Often just creating our custom data is not enough; we want to somehow combine it with SAP Standard. Here we have several options:

Case 1: Single Fields to be saved on same level as standard

If you have single, non-connected fields to add to a SAP Standard object, we want to use Custom Fields (App on SAP Fiori Apps Reference Library) app and just add field-by-field. Coming back to the bookshop example and the author; we would not want to create field "Author First Name", and another field, "Author Last Name" and then add both to the Product Master Data, for example. But, we could add a field called "Number of Pages of Book", numeric, to the product master data:

Case 2: Single Field where only certain values (from a drop-down) should be selected

When we have a field where we want to restrict what the user enters, we can again use Custom Fields app, and choose as field type "Code List". This lets us then maintain the possible values for users to enter directly in the Custom Fields app. In our example it could be the format of the book:

These values can of course be translated.

The 2nd option is to create a z-Domain/z-table with values in the dictionary, then create a CDS view as value help for those values, and then use that CDS view in Custom Fields, when selecting "Code List based on CDS View". I did this example for Book Genres:

This is in fact great as a "not so good" example. So we have a z-table but we won't create a maintenance dialog for sm30, because it is not clean core. Above I've set "@AbapCatalog.dataMaintenance" as #ALLOWED, meaning we can simply maintain the data in se16n, but also meaning we have no automatic transport of data and so on, and no regular user can do it, nor is it easy to control authorization for users who should be able to maintain this. So the book genre would have been better solved as Custom Business Object, but I wanted to show different options and also to highlight why a z-table maybe isn't the best solution. Next, I have to create CDS views that I can then use in Custom Fields and I need to 2, in order to follow the ABAP Cloud programming model:

Basic interface view for reading form the database table
Value help view using the basic interface view

Only now can I got to Custom Fields and add the Book Genre to Product master data:

Wait: what about Custom Reusable Elements - Code List?

If you are familiar with the key user apps you may know of Custom Reusable Elements (App on SAP Fiori Apps Reference Library). We know this app has custom libraries, meaning ABAP code, but also Code Lists. Having talked about using Code Lists in custom fields, when would be use this one then? This is simply put for Custom Business Objects. If your custom business object has a field where you want the restricted values functionality, you would first create it in this app. For example we could have a "popularity" field on the Author custom business object and we would want only few possible values:

When we add a field now in our custom business object (any custom business object), we select as type "Code List" and then pick one.

Case 3: Link Custom Object with Standard

If we have more than just single, disconnected fields, but instead we want to link a Standard object to our own data that has it's own table or even hierarchical tables (as in our author example), then we still use Custom Fields app. In Custom Fields as we add a new field, we can choose "Association to Business Object". If we do, we need to select the business object in the drop down, which includes all our Custom Business Object. For example:

Case 4: Combining data for reports

If our case is not to save master or transactional data, but instead use some custom data for reports, we have several options.

Use Custom CDS Views (Version 2) (App on SAP Fiori Apps Reference Library) to combine existing CDS views together for reporting (if your custom data has no CDS view yet, which it will have if you used Custom Business Object, you can get a developer to create one for you, option 3)
Use Custom Analytical Queries (App on SAP Fiori Apps Reference Library) if you need analytical capabilities with measures, dimensions, calculations, and so on. This app needs an analytical cube or query CDS, which a developer can create for you if not yet existing - option 3
Use on-stack development to create your own custom CDS views (analytical or transactional) and create any report and combination of standard and custom CDS views. This option can be used together with the first 2 above, or can even be used to create a custom reporting Fiori app with BAS on SAP BTP. This is the most powerful of all the options and allows for a lot freedom on creating exactly what you need. This can also be used if the data needs to be exposed as API to integrations or other purposes

Summary

I'm sure there are lots more cases for custom data and I doubt I can list them all. But the above show cases how to do it with key user apps and how they can help to do it faster, simpler, and have a nice user interface for the end user with input help. If you have a specific case you wonder about, just drop a comment and ask 😊 Hope this was helpful!

Release Assessment and Scope Dependency for SAP S/4HANA Cloud Public Edition: What is new in 2024

2024-04-07T13:03:42.624000+02:00

Introduction

To provide our customers of SAP S/4HANA Cloud Public Edition with disruption free upgrades and zero day 1 impact, we have been tirelessly improving release assessment and scope dependency tool to meet the latest customer demands.

We have made a few changes and improvements in the release assessment and scope dependency tool so that we can inform all Day 1 impacts, which are relevant to our customers proactively based on their usage.

Extensibility Objects

With the release of 2402.1 version of SAP S/4HANA Cloud Public Edition, all changes (Deletions/Deprecations/Changes) related to extensibility objects have been moved to the page Overview of Extensibility Objects. This now includes objects covering both Key User Extensibility and Developer Extensibility.

The tool release assessment and scope dependency is also updated and these are available under the tile ‘Extensibility Objects’ under the tab ‘Used Objects’

On clicking on the tile ‘Extensibility Objects’, the customer will be able to see a detailed view of the deletions/deprecations/changes

This table contains the following columns. Type of object, extensibility type, technical name of the object, object description, type of change, change format and additional information regarding the deletion/deprecation/change. The customer will also be able to navigate to the what’s new viewer to view the changes in detail.

All changes (Deletions/Deprecations/Changes) related to extensibility objects in a specific release are available under the tab ‘Complete What’s New Information’. This is not filtered based on a customer’s usage, but rather, it provides an overall view on all changes based on a specific release.

With this change, the contents inside the tiles ‘Deleted/Deprecated Apps, APIs and CDS Views’, ‘Changed and Must Know Information’ and New Features have been moved to the new tiles.

Deletions/Deprecations/Changes/New Feature related to Applications have now been moved under the tile ‘Apps’.

Deletions/Deprecation of the APIs and CDS views are now clubbed along with other extensibility objects under the tile ‘Extensibility Objects’

Please not that usage of Business Events are not considered here. This means that release information related to Business Events will be available only under the tab 'Complete What's New Information'

Successor Companion

Successor companion will be available as a new tab with the latest version of release assessment and scope dependency. This will be available as a new tab in the tool. As of initial release, this will be available only for the major releases, but we will be extending this for continuous deliveries as well, in the upcoming versions of the tool.

Successor companion consists of two tiles.

Scope Item Impact
Deprecation Coverage

Scope Item Impact

Scope item impact provides you with a bird’s eye view on a customer’s scope item implementation statistics on their SAP S/4HANA Cloud Public Edition landscape across all tenants based on their usage.

If we take the data in the screenshot provided above as an example, we can understand that ~47% of all the activate scope items are being used by the customer. This means that there is an improvement scope of ~43% for the customer to derive the complete value based on the scope items activated by the customer to improve their business as envisioned by SAP.

Deprecation Coverage

With ‘Deprecation Coverage’, we want to give you a proactive view on what are the deprecated (API Deprecation Policy, CDS view Deprecation policy) objects and attributes that are currently being used by a customer and we also provide the name of the successors which are released for these deprecated objects/attributes, so that the customer can move to these successors by the time these deprecated objects/attributes are deleted.

We derive this by looking at the past few month’s usage data of a customer to understand if the customer is using an object/attribute that was deprecated in the past releases and we proactively inform the customer that they are using a deprecated object/attribute.

As explained, this consists of two levels of information.

Deprecated Attributes
Deprecated Objects

Deprecated Attributes

Deprecated attributes refer to fields of APIs or CDS views, that are deprecated/decommissioned. These attributes will have a successor attribute released for it, when they were deprecated.

This will contain the list of objects with attributes that were deprecated in an older release, that are still being used by the customer along with its successor attribute. If I can take the example of a CDS view, the customer might have created custom CDS views using these objects and the deprecated attribute might have been added as a field in the custom CDS view. This will help the customer to readjust that custom CDS view with its successor.

Deprecated Objects

Deprecated objects refer to Apps, APIs of CDS views that are deprecated.

This will contain the list of APIs, Apps or CDS views that are deprecated in an older release, that are still being used by the customer. We provide the name of object that was release as a successor for this deprecated object so that customer could adopt this to avoid any possible disruptions during upgrade. This also means that customer will be informed proactively about new objects. which will have better features compared to the deprecated objects.

Conclusion

We are continuously trying to add more features to the tool so that upgrades are hassle free and our customer can derive more value out of their SAP S/4HANA Cloud Public Edition implementation. Keep watching this space for more updates on release assessment and scope dependency.

You can go thru our FAQ blog if you have any questions regarding release assessment and scope dependency.

Cloud BADI Implementation via Developer Extensibility

2024-04-12T19:31:23.877000+02:00

Scenario

The requirement is to update/add withholding tax code details of Suppliers for Country/Region Argentina in Vendor Master based on Tax Number of Suppliers.

For this demo, we will add new tax codes to be updated for existing withholding tax configuration in vendor master and also add new withholding tax configuration line.

To achieve the same, we will make use of available Badi.

Steps

Find the available cloud BADI for the requirement.

All available cloud BADIs can be found on SAP Business Accelerator Hub.

Follow Path: Business Accelerator Hub -> S/4 Hana Cloud -> Developer Extensibility -> Business Add-Ins.

We will use BADI - ES_FIWTAR_UPDATE_TAXCODE for our scenario.

Login to Cloud Project via ADT

You will need development experience with ADT and ABAP objects to implement Badi.

Start ADT.

Select ADT menu File -> New -> ABAP Cloud Project.

Add new cloud project

Enter the system URL of your system.

Enter Url

Press the button "Open Logon Page in Browser."

Logon with your email address <id>@sap.com and your password.

Enter login credentials

Create Package

After successful logon to the system, create your own package as below picture just like this is done in normal ABAP development systems. Take care of the super package and correct package type and that your package starts with Z.

Create Package

Then create a new transport request for it or select existing if it’s already present on your name and save it.

Select / Create Transport request

Finally, verify that the correct language version is set for your package as shown below. This should happen automatically.

Verify language version

Implement Badi

In order to create an own Badi implementation, first select New-> Other ABAP Repository Object.

Create Object

And filter for “BAdI” to reduce the result list of objects to be created. Then select “BAdI Enhancement Implementation” and click on “Next”.

Select Badi Enhancement Implementation

Enter a name (starting with Z) and if needed also your previously created package and find the Enhancement Spot that holds the released implementations you want to test.

Create Badi Enhancement Implementation

Finally Save it in transport request.

You will then see the screen for the BadI Enhancement Implementation as shown below. Now click the “Add BadI Implementation...” button.

Add Badi Implementation

Browse for the Badi you would like to implement.

Browse Badi

It will show only BAdIs available in the selected BAdI spot.

Select Badi

Finally, provide a name for the implementation (starting with Z) and add it.

Add Badi Implementation

The BAdI Enhancement Implementation will now complain about a missing implementation class. Just click on the highlighted link to get the creation wizard opened.

Click Implementing Class

Provide a class name (starting with Z) and fill in your previously created package and click on “Next”.

ABAP Class

Select your existing transport and press “Finish”.

Now, empty Badi implementation class is created as shown below.

Empty Class

Implement custom logic in class methods and active all objects.

Below is example code of one of the methods where updating new tax code for all existing tax codes as '00' and new tax code details entry is added to be created in withholding tax configuration of a supplier.

  METHOD if_fiwtar_update_taxcode~populate_new_tax_code.

    FIELD-SYMBOLS: <ls_data> TYPE if_fiwtar_update_taxcode~ty_vdmr_file.
    DATA: lt_data TYPE if_fiwtar_update_taxcode~tt_vdmr_file.
    DATA: ls_new TYPE if_fiwtar_update_taxcode~ty_vdmr_file.

    lt_data = it_vdmr_file.

    LOOP AT lt_data ASSIGNING <ls_data>.
      <ls_data>-withcd_new = '00'.
    ENDLOOP.

    ls_new = VALUE #( lifnr      = '0000117375'
                      stcd1      = '30123430014'
                      name1      = ''
                      witht      = 'BA'
                      wt_withcd  = ''
                      qsatz      = ''
                      withcd_new = '01'
                      file_rate  = '' ).

    APPEND ls_new TO lt_data.
    ct_output = lt_data.

  ENDMETHOD.

Badi is implemented and now we can test the same.

Test Badi Implementation

Open App - "Update Tax Code and Open items - Region" for Argentina Province.

Provide Inputs to the screen.

Execute.

As we can see, For one existing line New tax code is filled as '00' and new line is added from Badi implementation.

Summary

summary

Thank you for reading!

Drop a like or comment below if you found the above steps useful.

Consuming CAPM Application's OData service into SAP Fiori Application in Business Application Studio

2024-04-16T12:50:31.978000+02:00

OBJECTIVE-:

Consuming OData Service of CAPM Application into SAP Fiori Application in Business Application Studio.

CAPM (Cloud Application Programming Model)-:

It is an open-source framework that uses tools, libraries, and languages to create applications that can be used across multiple SAP products. CAPM is a multi-target application that runs at different times, with the persistence layer running in the HANA DB run time, the server layer running in the Node.js run time, and the UI/UX layer running in the browser run time.

CAPM is one of the approaches to developing cloud applications using the BTP platform. CAPM offers a more structured and seamless framework for data modelling and enhancing integration with services.

Advantage of CAPM over other approaches-:

It enables full-stack development in the same environment. (BAS), eliminating the need to switch between different environments for the backend and frontend development.
It offers flexibility in language selection, allowing developers to work with multiple languages according to their needs. BAS provides easy connectivity to required extensions for this purpose.
Seamless integration with git and other applications via APIs facilitating extension or development of the application.
Automatically handling dependencies to a certain extent, reducing frustration, and improving development speed. For example, handling the OData after exposing all entities and making it easier to consume in the UI.

Prerequisites-:

Create a CAPM project.
Log in to Cloud Foundry Credentials.
Ensure the HANA Database is created and running (I Used it for storage and data creation).

Set up a Dev Space.
Create a SAP Build Work Zone instance to act as a Fiori Launchpad for the CAPM Application

You Have to create a new Destination in BTP (Connectivity -> Destination)-:

This destination will be used for passing system information when creating a Fiori Application.

For the URL, DEPLOY YOUR APPLICATION IN CLOUD FOUNDRY (Cloud Foundry ->Spaces ->Dev (Space Name)->Your Service (here it is CAPMChetan-srv) and copy Application Routes).

This URL will be shown only when you deploy your CAPM Application in Cloud Foundry-> A new blog will be there to deploy the CAPM Application.

For Authorization, use the same authorization as created in the package.json -> a new blog will create a security configuration.

Now that the destination for the service is configured, proceed to create a FIORI APP: -

Open SAP BAS (Business Application Studio).
Open DEV Space where you want to create a Fiori Application.
Go to File -> New Project From template.
Choose a project from the Template (SAP Fiori Application).

Choose any Template of your choice.

In Data Source choose to connect to a system.

Specify the Destination created earlier.

In the service path, specify the service path of the OData service that can be obtained by running the command “cds watch –profile hybrid” in your CAPM Project.

Click on next.

Select any entity from the given list of entities you created in your project.

Customize the project attributes.

Choose the target as Cloud Foundry and select the Destination name among the list of destination names (You can go with either Local CAPM Project API and the name of your destination too).

Now, your FIORI project is created and is ready to use.

Go to run configuration and start the project as usual.

You can now run this Fiori Application which is the result of an Application created from CAPM.

Debug Application Job on S/4HANA Public Cloud

2024-04-16T13:01:48.420000+02:00

As of today (Apr 10, 2024), SAP has not provided a method to debug application job on S/4HANA Public Cloud (related Question by @rammel ) or provided a method to pass parameters to the class via IF_OO_ADT_CLASSRUN (related Question by @fabianlupa answered by @horst_keller ). Below is a workaround method until SAP provides a way to do either of these options.

Every Class used in a Custom Job catalog uses interfaces IF_APJ_DT_EXEC_OBJECT and IF_APJ_RT_EXEC_OBJECT. IF_APJ_DT_EXEC_OBJECT~GET_PARAMETERS provides the parameter definition and IF_APJ_RT_EXEC_OBJECT~EXECUTE is responsible to receive the job parameters from the caller and execute the business logic.

The idea implemented here, is to create a wrapper to reuse this functionality to call the Execute method. The wrapper is created as a HTTP service so that it can be called from external parties to pass the required parameters.

So, first lets create a HTTP service. If you plan to use the plugin attached here, then please make sure to use the same name for HTTP service as ZSRV_ADT_PLUGIN_EXEC_JOBCLASS, since that name is used in the plugin.

Below is the code I used in the handler class. Please feel free to improvise this class, to have better authorization checks or validations according to your needs.

class zcl_adt_plugin_exec_jobclass definition
  public
  create public .

  public section.

    interfaces if_http_service_extension .
  protected section.
  private section.
endclass.



class zcl_adt_plugin_exec_jobclass implementation.
  method if_http_service_extension~handle_request.
    types: lty_char   type c length 100,
           ltyt_range type range of lty_char.
    data: lo_definition type ref to if_apj_dt_exec_object,
          lo_runtime    type ref to if_apj_rt_exec_object,
          lt_values     type if_apj_rt_exec_object=>tt_templ_val,
          begin of ls_value,
            param type string,
            range type ltyt_range,
          end of ls_value,
          lv_params type string.
    data(lt_form) = request->get_form_fields( ).
    loop at lt_form reference into data(lo_form).
      translate lo_form->name to upper case.
    endloop.
    read table lt_form into data(ls_form) with key name = 'CLASSNAME'.
    if sy-subrc eq 0.
      try.
          translate ls_form-value to upper case.
          create object lo_definition type (ls_form-value).
          create object lo_runtime type (ls_form-value).
          lo_definition->get_parameters( importing et_parameter_def = data(lt_params) ).
        catch cx_root into data(lo_root).
          response->set_text( |Class { ls_form-value } is invalid| ).
          response->set_status( 400 ).
          return.
      endtry.

      case request->get_method( ).
        when 'GET'.
          loop at lt_params into data(ls_param).
            lv_params = lv_params &&
                        cond #( when lv_params is not initial then ',' && cl_abap_char_utilities=>newline ) &&
                        |"{ ls_param-selname }":| &&
                        cond #( when ls_param-kind = 'S' then |[\{"SIGN":"I","OPTION":"EQ","LOW":"","HIGH":""\}]| else |""| ).
          endloop.
          lv_params = |\{{ cl_abap_char_utilities=>newline }{ lv_params }{ cl_abap_char_utilities=>newline }\}|.
          response->set_text( lv_params ).
        when 'POST'.
          try.
              data(lv_body) = request->get_text( ).
              loop at lt_params into ls_param.
                /ui2/cl_json=>deserialize( exporting json          = lv_body
                                                     name_mappings = value #( ( abap = cond #( when ls_param-kind = 'S' then 'RANGE' else 'PARAM' )
                                                                                json = ls_param-selname ) )
                                           changing  data          = ls_value ).
                if ls_param-kind = 'S'.
                  loop at ls_value-range into data(ls_rng).
                    append value #( selname = ls_param-selname sign = ls_rng-sign option = ls_rng-option low = ls_rng-low high = ls_rng-high ) to lt_values.
                  endloop.
                elseif ls_value-param is not initial.
                  append value #( selname = ls_param-selname low = ls_value-param ) to lt_values.
                endif.
                clear ls_value.
              endloop.
              lo_runtime->execute( lt_values ).
            catch cx_root.
              response->set_status( 400 ).
              return.
          endtry.
      endcase.
      response->set_content_type( 'application/json' ).
      response->set_status( 200 ).
    endif.
  endmethod.
endclass.

If you plan to use the custom plugin, then copy the plugin to the plugins folder of your Eclipse installation.

Close the eclipse application and re-open it from command line using command eclipse.exe -clean, so that it re-reads the plugin folder.

Now, logon to SAP system via eclipse. In order to activate debugging request from plugin, please activate the following checkbox, for the ABAP Cloud Project.

Open the custom Job Catalog related to the class that you would like to debug. Once you are the Job Catalog editor, open Run menu. If Eclipse found and installed the plugin correctly, then you should be able to see a new option saying "Run Job Class" as highlighted below. (This option will only be visible while on Job Catalog editor view)

Now, open the related class and add a breakpoint in the Execute method of the Class.

You can now go back to the Job Catalog Editor and select the option "Run Job Class". This will call the custom HTTP service that was created and which will internally create a JSON payload of the parameter list. It will then popup a dialog for you to edit the JSON.

Modify the payload to pass values to each of the provided parameters in the JSON and hit OK.

If you have setup everything right, then a new Debugger session will start and break at the breakpoint that you have set earlier.

If you do not plan to use the plugin, other options may be to use tools like Postman or Restman to GET or POST, JSON payloads to the custom HTTP service.

Plugin can be downloaded from here.

Building Low Code Extensions with Key User Extensibility in SAP S/4HANA and SAP Build

2024-04-19T08:08:19.293000+02:00

More than one year ago, SAP announced SAP Build, a toolset for creating low code / now code (LCNC) extension on SAP BTP (Low-Code App Development and Automation Solutions | SAP Build). In this blog I want to share my ideas on how both tools can be combined to build powerful extensions.

Who Are Key Users?

Who are key users? An excellent answer to this question has been given by my colleague @Jocelyn_Dart in her blog SAP Fiori for SAP S/4HANA – What is Key User Exten... - SAP Community. I want to briefly summarize it here: key users are users who are authorized to make changes on behalf of other users, typically for the users of a special group or department. Examples are:

During your project, you might designate your functional consultants as your key users to make some initial adjustments as they discuss business needs directly with your business stakeholders.
Some organizations have a central process governance group who might be designated as responsible for key user changes or for certain types of key user extensions. For example, you might want your central process governance group to control adding custom fields, so that you don't end up with several teams creating similar fields.
You might give some key user capabilities to your IT team or even selected developers – as key user functions can be the most effective way to extend your apps and the essential way to add custom fields. For example, as you build your skills into intelligent technologies, you might want your IT team to make some initial settings for your pilot machine learning or situation handling use cases.

Key user extensibility uses a no-code/low-code approach so business users can make the changes themselves. Thus, you can minimize lost-in-translation errors and communication overhead between business and IT.

What do key users expect?

Well, key users expect that they can create extensions:

Simple – no-code/low-code (LCNC)
Cost-effective – with minimum cost/effort/skill
Upgrade-stable – extensions are automatically retained as you upgrade releases
Safe - changes can be tested in a draft mode, they can be undone or reset, if needed

Example: You all know that business processes require governance processes and not all processes are handled by central IT systems. So, key users start creating excels or word templates and over time they will add more and more logic (calculations, validations, etc. to it). But in the end, the data in the excel or word files must be synchronized with the central IT systems. So the more key users can adapt the system itself, the less overhead for data synchronization is needed.

What are Key User Extensibility Tools and What is SAP Build?

Key User Extensibility Tools are Fiori apps that are part of SAP S/4HANA ( SAP S/4HANA ) (or other products such as SAP IBP) and that can be used by key users to adapt SAP applications and services (e.g. adapt the UI, forms, add custom fields and logic) or to create small custom applications (e.g. create custom CDS views, custom business objects, …). In other words, it is the LCNC offering that is embedded in the prod

SAP Build ( SAP Build ) is a set of LCNC tools on SAP BTP:

SAP Build Apps is a visual programming environment where citizen and professional developers can build enterprise-ready custom applications without writing any code. With hundreds of pre-built components and logic functions, you can jumpstart your application projects and reduce development time. Explore how you can develop web and native mobile cross-platform apps while integrating to other SAP systems with drag-and-drop ease.
SAP Build Process Automation allows you to simplify automation of business processes with visual drag-and-drop tools. It enables both citizen and professional developers to easily digitize their workflows without writing code. There are hundreds of pre-built content packages and connectors you can use to jumpstart your automation projects and save on development time.
SAP Build Work Zone enables you to bring together all types of content, UI tools, IT systems, content repositories, applications, and channels using drag-and-drop and customization tools to create portals, intranets, and workspaces.

The following picture shows the four options for building extensions for SAP S/4HANA in context.

Low code/no code options for key users (already explained).
Options for developers:
- the on-stack SAP S/4HANA Cloud ABAP Environment
- SAP Build Code or ABAP Environment as the side-by-side extensibility options on SAP BTP

Why Two Different Tools Sets? When Do I Use What?

Key user tools are used for local extension. If you want to adapt a Fiori UI (e.g. hide or rename fields on the UI), or you want add a validation for a field, you have to do it locally in the app. And this is why you use the embedded key user tools for this case. Also, if you want to add a custom field or custom tables to the S/4HANA data model and you want to use the data closely together with the S/4HANA data, for example in analytics.

But if you want to create a new UI or a new process, for example a workflow, not only one S/4HANA may be involved; it makes sense to create these extensions in a central “hub” on SAP BTP.

Let me explain this in two examples:

Example 1: New UI for a Custom Business Object

With the Custom Business Object key user app, you can create new custom tables in SAP S/4HANA and on top of the tables CDS views and a business object with a generic maintenance UI without writing one line of code. The CDS views that are generated on top of the tables are available for other key user extensions, for example in custom logic or custom analytical applications. The generic maintenance UI that comes with the custom business object is sufficient for most cases.

But in some cases, you would expect a more elaborate UI for a broader audience. You might even need a UI for users that do not have direct access to the SAP S/4HANA system (= they have no business user in the SAP S/4HANA system). Here, SAP Build Apps is the ideal tool to create an elaborate UI without being a developer and writing code.

The following tutorial leads you through a typical use case:
Extending SAP S/4HANA with SAP Build Apps and Key User Extensibility | SAP Learning

An app is created that helps users in goods inbound processing to check the incoming goods and perform specific checks on the goods (e.g. for chemical or other dangerous goods). The specific checks and check results are stored in custom business objects. An app created with SAP Build Apps uses the standard SAP services for products and purchase orders and the services generated for the custom business object to guide the user through the check process.

Another tutorial that you can use for a start is the following:
https://developers.sap.com/tutorials/build-apps-s4hana-crud.html

The tutorial describes how to build a UI with SAP Build App on an S/4HANA OData service, namely the Business Partner. You can adapt the tutorial to custom business objects (CBO) in S/4. Instead of the A_BusinessPartner entity in the tutorial, you would use the root entity of your custom business object, and instead of the A_BusinessPartnerAddress entity you would use a sub-node of your custom business object.

Example 2: New Process for a Custom Business Object

Key users typically define the processes for a specific department or user group, which includes workflow. To empower the key user to implement their processes themselves, it makes sense to combine the Custom Business Object key user app and the process automation on SAP BTP.

Thus, the custom business object is created locally in the SAP S/4HANA system (so that it can be used by other extensions). Conversely, the process is created centrally on SAP BTP, so that they can be combined with other processes and potentially other data sources that are available on SAP BTP.

A typical example is: A bonus plan application is developed as custom business object using key user extensibility in SAP S/4HANA. When a bonus plan is created, an approval is required. This process is created with SAP Build Process Automation and runs on SAP BTP. When the approval is finished, the BTP process calls the bonus plan service and creates the bonus plan SAP S/4HANA.

The following tutorials can be used to implement such a use case:

Create a custom business object:
- Create Custom Business Objects in S/4HANA Cloud | SAP Tutorials
Create an approval process and trigger the creation of a business object instance from a process: with SAP Build Build Process Automation
- Build Your First Business Process with SAP Build Process Automation | SAP Tutorials
- https://developers.sap.com/group.connect-process-external-sap-bpa.html
- Note that these tutorials show you how to create an approval process and call a service on SAP S/4HANA for an SAP business object. But you can use these tutorials also to create a custom business object.

Summary

In this blog post, I explain why it makes sense to combine the capabilities of the local key user extensibility tools with the capabilities of SAP Build to empower key users to create powerful extensions without any lines of code.

SAP S/4HANA Cloud ABAP开发案例之八：物料临期管理App

2024-04-19T09:11:36.318000+02:00

紧随这篇博客，今天我们将再次逐步详细地介绍一个利用SAP S/4HANA Cloud三系统来做开发扩展的案例。

1. 案例背景

我们经常听到启用批次管理的客户在问是否有对临近效期物料的提醒、是否有对临近效期物料的批量查询报表，在标准产品中要查询相关信息需要检索多张报表，比如库存报表、批次信息等。通过利用开发人员可扩展性，我们开发了一个定制的物料临期管理App，并嵌入到SAP S/4HANA Cloud系统中。旨在帮助企业智能化地管理物料效期，提高供应链管理效率。关于业务上该自开发案例的价值，可参考此博客。

每个企业由于不同业务管理需要，可能对临近效期的提醒范围定义不同，我们还开发了警示灯自定义阈值配置app，用户可以自定义设置效期多少范围需显示为红灯，多少范围需显示为黄灯，多少范围需显示为绿灯，自定义设置满足不同企业客制化效期管理需求。

2. 后台服务开发

2.1 创建CDS数据模型

创建数据定义YCDS_DUE_MAT_LIST

@AbapCatalog.sqlViewName: 'YDUEMATMANGE'
@AbapCatalog.compiler.compareFilter: true
//@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Material Due Date List'
define view YCDS_DUE_MAT_LIST as select from I_Batch
inner join YCDS_SUM_STOCK_01 on YCDS_SUM_STOCK_01.Material = I_Batch.Material
                                       and YCDS_SUM_STOCK_01.Plant = I_Batch.Plant
                                       and YCDS_SUM_STOCK_01.Batch = I_Batch.Batch
association [1..1] to I_Product on I_Product.Product = I_Batch.Material
association [1..1] to I_ProductDescription on I_ProductDescription.Product = I_Batch.Material
                                          and I_ProductDescription.Language = $session.system_language
association [1..1] to I_Plant on I_Plant.Plant = I_Batch.Plant
                              and I_Plant.Language = $session.system_language
association [1..1] to I_Supplier on I_Supplier.Supplier = I_Batch.Supplier                           
{
  key I_Batch.Material,
  key I_Batch.Batch,
  key I_Batch.Plant,
  key I_Batch.Supplier,
  key I_Batch.BatchBySupplier,
//  key YCDS_SUM_STOCK_01.InventoryStockType,
//  key YCDS_SUM_STOCK_01.MatlDocLatestPostgDate,
  YCDS_SUM_STOCK_01.StorageLocation,
  YCDS_SUM_STOCK_01.MatlWrhsStkQtyInMatlBaseUnit,
  I_Batch.MatlBatchIsInRstrcdUseStock,
  I_Batch.ShelfLifeExpirationDate,
  I_Batch.ManufactureDate,
  I_Product.BaseUnit,
  I_ProductDescription.ProductDescription,
  I_Plant.PlantName,
  I_Supplier.SupplierName,
  case when I_Batch.MatlBatchIsInRstrcdUseStock = 'X' then 'Restricted' else 'Unrestricted' end as BatchStatus,
  $session.system_date as curr_date
}
where I_Batch.ShelfLifeExpirationDate is not initial
  and YCDS_SUM_STOCK_01.MatlWrhsStkQtyInMatlBaseUnit <> 0

创建数据定义YCDS_DUE_MAT_LIST2

@AbapCatalog.sqlViewName: 'YDUEMATMANGE2'
@AbapCatalog.compiler.compareFilter: true
@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Material Due Date List'
define view YCDS_DUE_MAT_LIST2 as select from YCDS_DUE_MAT_LIST
association [1..1] to I_StorageLocation on I_StorageLocation.StorageLocation = YCDS_DUE_MAT_LIST.StorageLocation
                                       and I_StorageLocation.Plant           = YCDS_DUE_MAT_LIST.Plant
{
  key YCDS_DUE_MAT_LIST.Material,
  key YCDS_DUE_MAT_LIST.Plant,
  key YCDS_DUE_MAT_LIST.StorageLocation,
  key YCDS_DUE_MAT_LIST.Batch,
  key YCDS_DUE_MAT_LIST.Supplier,
//  key YCDS_DUE_MAT_LIST.InventoryStockType,
//  key YCDS_DUE_MAT_LIST.MatlDocLatestPostgDate,
  YCDS_DUE_MAT_LIST.ProductDescription,
  YCDS_DUE_MAT_LIST.PlantName,
  I_StorageLocation.StorageLocationName,
  YCDS_DUE_MAT_LIST.BatchBySupplier,
  YCDS_DUE_MAT_LIST.SupplierName,
  MatlWrhsStkQtyInMatlBaseUnit,
  YCDS_DUE_MAT_LIST.BaseUnit,
  YCDS_DUE_MAT_LIST.ShelfLifeExpirationDate,
  YCDS_DUE_MAT_LIST.ManufactureDate,
  YCDS_DUE_MAT_LIST.BatchStatus,
  dats_days_between(YCDS_DUE_MAT_LIST.curr_date,YCDS_DUE_MAT_LIST.ShelfLifeExpirationDate) as remaining_days
}

创建数据定义YCDS_SUM_STOCK_01

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Sum of Stock 01'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.usageType:{
  serviceQuality: #X,
  sizeCategory: #S,
  dataClass: #MIXED
}
define view entity YCDS_SUM_STOCK_01 as select from I_MaterialStock_2
{
  key Material,
  key Plant,
  key StorageLocation,
  key Batch,
  key MaterialBaseUnit,
  @Semantics.quantity.unitOfMeasure: 'MaterialBaseUnit'
  @Aggregation.default: #SUM
  sum( MatlWrhsStkQtyInMatlBaseUnit ) as MatlWrhsStkQtyInMatlBaseUnit
}
where InventoryStockType = '01'
group by Material, Plant, StorageLocation, Batch, MaterialBaseUnit

2.2 创建Metadata Extensions

创建新的Metadata Extension：YC_DUE_MAT_LIST

@Metadata.layer: #CUSTOMER

@UI.headerInfo.title.type: #STANDARD
@UI.headerInfo.title.label: 'Material Shelf Life Management'
@UI.headerInfo.description.type: #STANDARD
@UI.headerInfo.typeName: 'Material Due List'
@UI.headerInfo.typeNamePlural: 'Material Shelf Life Management'

annotate view YC_DUE_MAT_LIST with
{

  @UI.facet: [{ id: 'Material',
                purpose: #STANDARD,
                type: #IDENTIFICATION_REFERENCE,
                label: 'Material',
                position: 10}
                 ]

  @UI:{ lineItem: [{ position: 10 }],
        lineItem: [{label: 'Material'}],
        identification: [{ position: 10 }],
        selectionField: [{ position: 20 }]
        }
  Material;
  @UI:{ lineItem: [{ position: 20 }],
        lineItem: [{label: 'Material Description'} ],
        identification: [{ position: 20 }]
        }
  @UI.lineItem: [{exclude: true}]
  ProductDescription;
  @UI:{ lineItem: [{ position: 30 }],
        lineItem: [{label: 'Plant'}],
        identification: [{ position: 30 }],
        selectionField: [{ position: 10 }]
        }
  Plant;
  @UI:{ lineItem: [{ position: 40 }],
        lineItem: [{label: 'Plant Name'}],
        identification: [{ position: 40 }]
        }
  @UI.lineItem: [{exclude: true}]
  PlantName;
  @UI.lineItem: [{ position: 50 }]
  @UI.lineItem: [{label: 'Storage Location'}]
  @UI.identification: [{ position: 50 }]
  @UI.selectionField: [{position: 50}]
  StorageLocation;
  @UI.lineItem: [{ position: 60 }]
  @UI.lineItem: [{label: 'Storage Location Name'}]
  @UI.identification: [{ position: 60 }]
  @UI.lineItem: [{exclude: true}]
  StorageLocationName;
  @UI.lineItem: [{ position: 70 }]
  @UI.lineItem: [{label: 'Batch'}]
  @UI.identification: [{ position: 70 }]
  @UI.selectionField: [{position: 70}]
  Batch;
  @UI.lineItem: [{ position: 80 }]
  @UI.lineItem: [{label: 'Supplier Batch'}]
  @UI.identification: [{ position: 80 }]
  @UI.selectionField: [{position: 80}]
  BatchBySupplier;
  @UI.lineItem: [{ position: 90 }]
  @UI.lineItem: [{label: 'Supplier'}]
  @UI.identification: [{ position: 90 }]
  Supplier;
  @UI.lineItem: [{ position: 100 }]
  @UI.lineItem: [{label: 'Supplier Name'}]
  @UI.identification: [{ position: 100 }]
  @UI.lineItem: [{exclude: true}]
  SupplierName;
  @UI.lineItem: [{ position: 110 }]
  @UI.lineItem: [{label: 'Unrestricted Inventory Qty'}]
  @UI.identification: [{ position: 110 }]
  MatlWrhsStkQtyInMatlBaseUnit;
  @UI.lineItem: [{ position: 120 }]
  @UI.lineItem: [{label: 'Unit'}]
  @UI.identification: [{ position: 120 }]
//  @UI.lineItem: [{exclude: true}]
  @UI.hidden: true
  BaseUnit;
  @UI.lineItem: [{ position: 130 }]
  @UI.lineItem: [{label: 'Expiration Date'}]
  @UI.identification: [{ position: 130 }]
  ShelfLifeExpirationDate;
  @UI.lineItem: [{ position: 140 }]
  @UI.lineItem: [{label: 'Manufacture Date'}]
  @UI.identification: [{ position: 140 }]
  @UI.lineItem: [{exclude: true}]
  ManufactureDate;
  @UI.lineItem: [{ position: 150 }]
  @UI.lineItem: [{label: 'Batch Status'}]
  @UI.identification: [{ position: 150 }]
  @UI.lineItem: [{exclude: true}]
  BatchStatus;
  @UI.lineItem: [{ position: 160, importance: #HIGH }]
  @UI.lineItem: [{label: 'Remaining Days'}]
  @UI.identification: [{ position: 160 }]
  remaining_days;
  @UI.lineItem: [{ position: 170, value: 'due_range', criticality: 'Criticality' }]
  @UI.lineItem: [{label: 'Due Date Range'}]
  @UI.identification: [{ position: 170 }]
  due_range;    
//  @UI.hidden: true
//  InventoryStockType;
//  @UI.hidden: true
//  MatlDocLatestPostgDate;
  @UI.hidden: true
  Criticality;
}

2.3 创建Service Definition和Service Binding

我们可以通过预览的方式查看发布的服务：

3. 前台应用开发

首先在BTP创建Destination：

然后打开BAS服务，选择SAP Fiori Worklist Application：

发布完成，部署完权限之后，就可以看到App：

以上是该案例——物料临期管理自开发应用的步骤介绍。希望通过此案例的介绍能让您了解到三系统开发能实现的常见功能。

SAP S/4HANA Cloud, public edition, ABAP Environment Case 8: Material Shelf Life Management

2024-04-19T13:16:11.809000+02:00

This is a detailed step-by-step technical guide document to introduce a Developer Extensibility case followed by this blog.

1. Case Background:

We frequently hear inquiries from clients who have enabled batch management, asking whether there are reminders for nearing expiry materials and batch query reports for such materials. In standard products, retrieving relevant information often requires searching through multiple reports, such as inventory reports and batch details. To meet this demand, we have developed a Material Shelf Life Management App on S/4HANA public cloud through developer extensibility (also known as cloud ABAP development), aiming to help enterprises intelligently manage material Shelf Life and enhance supply chain management efficiency. Regarding the business value of this use case, you can refer to this blog for details.

Due to varying business management needs, each company may define different ranges for nearing expiry reminders. The Customizable Warning Threshold Configuration App allows users to set customized ranges for when to display red, yellow, or green warning lights, meeting the diverse customization needs of different enterprises for expiry management.

2. Backend Service Development:

2.1 Create CDS Data Model

Create Data Definition: YCDS_DUE_MAT_LIST

@AbapCatalog.sqlViewName: 'YDUEMATMANGE'
@AbapCatalog.compiler.compareFilter: true
//@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Material Due Date List'
define view YCDS_DUE_MAT_LIST as select from I_Batch
inner join YCDS_SUM_STOCK_01 on YCDS_SUM_STOCK_01.Material = I_Batch.Material
                                       and YCDS_SUM_STOCK_01.Plant = I_Batch.Plant
                                       and YCDS_SUM_STOCK_01.Batch = I_Batch.Batch
association [1..1] to I_Product on I_Product.Product = I_Batch.Material
association [1..1] to I_ProductDescription on I_ProductDescription.Product = I_Batch.Material
                                          and I_ProductDescription.Language = $session.system_language
association [1..1] to I_Plant on I_Plant.Plant = I_Batch.Plant
                              and I_Plant.Language = $session.system_language
association [1..1] to I_Supplier on I_Supplier.Supplier = I_Batch.Supplier                           
{
  key I_Batch.Material,
  key I_Batch.Batch,
  key I_Batch.Plant,
  key I_Batch.Supplier,
  key I_Batch.BatchBySupplier,
//  key YCDS_SUM_STOCK_01.InventoryStockType,
//  key YCDS_SUM_STOCK_01.MatlDocLatestPostgDate,
  YCDS_SUM_STOCK_01.StorageLocation,
  YCDS_SUM_STOCK_01.MatlWrhsStkQtyInMatlBaseUnit,
  I_Batch.MatlBatchIsInRstrcdUseStock,
  I_Batch.ShelfLifeExpirationDate,
  I_Batch.ManufactureDate,
  I_Product.BaseUnit,
  I_ProductDescription.ProductDescription,
  I_Plant.PlantName,
  I_Supplier.SupplierName,
  case when I_Batch.MatlBatchIsInRstrcdUseStock = 'X' then 'Restricted' else 'Unrestricted' end as BatchStatus,
  $session.system_date as curr_date
}
where I_Batch.ShelfLifeExpirationDate is not initial
  and YCDS_SUM_STOCK_01.MatlWrhsStkQtyInMatlBaseUnit <> 0

Create Data Definition: YCDS_DUE_MAT_LIST2

@AbapCatalog.sqlViewName: 'YDUEMATMANGE2'
@AbapCatalog.compiler.compareFilter: true
@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Material Due Date List'
define view YCDS_DUE_MAT_LIST2 as select from YCDS_DUE_MAT_LIST
association [1..1] to I_StorageLocation on I_StorageLocation.StorageLocation = YCDS_DUE_MAT_LIST.StorageLocation
                                       and I_StorageLocation.Plant           = YCDS_DUE_MAT_LIST.Plant
{
  key YCDS_DUE_MAT_LIST.Material,
  key YCDS_DUE_MAT_LIST.Plant,
  key YCDS_DUE_MAT_LIST.StorageLocation,
  key YCDS_DUE_MAT_LIST.Batch,
  key YCDS_DUE_MAT_LIST.Supplier,
//  key YCDS_DUE_MAT_LIST.InventoryStockType,
//  key YCDS_DUE_MAT_LIST.MatlDocLatestPostgDate,
  YCDS_DUE_MAT_LIST.ProductDescription,
  YCDS_DUE_MAT_LIST.PlantName,
  I_StorageLocation.StorageLocationName,
  YCDS_DUE_MAT_LIST.BatchBySupplier,
  YCDS_DUE_MAT_LIST.SupplierName,
  MatlWrhsStkQtyInMatlBaseUnit,
  YCDS_DUE_MAT_LIST.BaseUnit,
  YCDS_DUE_MAT_LIST.ShelfLifeExpirationDate,
  YCDS_DUE_MAT_LIST.ManufactureDate,
  YCDS_DUE_MAT_LIST.BatchStatus,
  dats_days_between(YCDS_DUE_MAT_LIST.curr_date,YCDS_DUE_MAT_LIST.ShelfLifeExpirationDate) as remaining_days
}

Create Data Definition: YCDS_SUM_STOCK_01

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Sum of Stock 01'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.usageType:{
  serviceQuality: #X,
  sizeCategory: #S,
  dataClass: #MIXED
}
define view entity YCDS_SUM_STOCK_01 as select from I_MaterialStock_2
{
  key Material,
  key Plant,
  key StorageLocation,
  key Batch,
  key MaterialBaseUnit,
  @Semantics.quantity.unitOfMeasure: 'MaterialBaseUnit'
  @Aggregation.default: #SUM
  sum( MatlWrhsStkQtyInMatlBaseUnit ) as MatlWrhsStkQtyInMatlBaseUnit
}
where InventoryStockType = '01'
group by Material, Plant, StorageLocation, Batch, MaterialBaseUnit

2.2 Create Metadata Extensions

Create new Metadata Extension: YC_DUE_MAT_LIST

@Metadata.layer: #CUSTOMER

@UI.headerInfo.title.type: #STANDARD
@UI.headerInfo.title.label: 'Material Shelf Life Management'
@UI.headerInfo.description.type: #STANDARD
@UI.headerInfo.typeName: 'Material Due List'
@UI.headerInfo.typeNamePlural: 'Material Shelf Life Management'

annotate view YC_DUE_MAT_LIST with
{

  @UI.facet: [{ id: 'Material',
                purpose: #STANDARD,
                type: #IDENTIFICATION_REFERENCE,
                label: 'Material',
                position: 10}
                 ]

  @UI:{ lineItem: [{ position: 10 }],
        lineItem: [{label: 'Material'}],
        identification: [{ position: 10 }],
        selectionField: [{ position: 20 }]
        }
  Material;
  @UI:{ lineItem: [{ position: 20 }],
        lineItem: [{label: 'Material Description'} ],
        identification: [{ position: 20 }]
        }
  @UI.lineItem: [{exclude: true}]
  ProductDescription;
  @UI:{ lineItem: [{ position: 30 }],
        lineItem: [{label: 'Plant'}],
        identification: [{ position: 30 }],
        selectionField: [{ position: 10 }]
        }
  Plant;
  @UI:{ lineItem: [{ position: 40 }],
        lineItem: [{label: 'Plant Name'}],
        identification: [{ position: 40 }]
        }
  @UI.lineItem: [{exclude: true}]
  PlantName;
  @UI.lineItem: [{ position: 50 }]
  @UI.lineItem: [{label: 'Storage Location'}]
  @UI.identification: [{ position: 50 }]
  @UI.selectionField: [{position: 50}]
  StorageLocation;
  @UI.lineItem: [{ position: 60 }]
  @UI.lineItem: [{label: 'Storage Location Name'}]
  @UI.identification: [{ position: 60 }]
  @UI.lineItem: [{exclude: true}]
  StorageLocationName;
  @UI.lineItem: [{ position: 70 }]
  @UI.lineItem: [{label: 'Batch'}]
  @UI.identification: [{ position: 70 }]
  @UI.selectionField: [{position: 70}]
  Batch;
  @UI.lineItem: [{ position: 80 }]
  @UI.lineItem: [{label: 'Supplier Batch'}]
  @UI.identification: [{ position: 80 }]
  @UI.selectionField: [{position: 80}]
  BatchBySupplier;
  @UI.lineItem: [{ position: 90 }]
  @UI.lineItem: [{label: 'Supplier'}]
  @UI.identification: [{ position: 90 }]
  Supplier;
  @UI.lineItem: [{ position: 100 }]
  @UI.lineItem: [{label: 'Supplier Name'}]
  @UI.identification: [{ position: 100 }]
  @UI.lineItem: [{exclude: true}]
  SupplierName;
  @UI.lineItem: [{ position: 110 }]
  @UI.lineItem: [{label: 'Unrestricted Inventory Qty'}]
  @UI.identification: [{ position: 110 }]
  MatlWrhsStkQtyInMatlBaseUnit;
  @UI.lineItem: [{ position: 120 }]
  @UI.lineItem: [{label: 'Unit'}]
  @UI.identification: [{ position: 120 }]
//  @UI.lineItem: [{exclude: true}]
  @UI.hidden: true
  BaseUnit;
  @UI.lineItem: [{ position: 130 }]
  @UI.lineItem: [{label: 'Expiration Date'}]
  @UI.identification: [{ position: 130 }]
  ShelfLifeExpirationDate;
  @UI.lineItem: [{ position: 140 }]
  @UI.lineItem: [{label: 'Manufacture Date'}]
  @UI.identification: [{ position: 140 }]
  @UI.lineItem: [{exclude: true}]
  ManufactureDate;
  @UI.lineItem: [{ position: 150 }]
  @UI.lineItem: [{label: 'Batch Status'}]
  @UI.identification: [{ position: 150 }]
  @UI.lineItem: [{exclude: true}]
  BatchStatus;
  @UI.lineItem: [{ position: 160, importance: #HIGH }]
  @UI.lineItem: [{label: 'Remaining Days'}]
  @UI.identification: [{ position: 160 }]
  remaining_days;
  @UI.lineItem: [{ position: 170, value: 'due_range', criticality: 'Criticality' }]
  @UI.lineItem: [{label: 'Due Date Range'}]
  @UI.identification: [{ position: 170 }]
  due_range;    
//  @UI.hidden: true
//  InventoryStockType;
//  @UI.hidden: true
//  MatlDocLatestPostgDate;
  @UI.hidden: true
  Criticality;
}

2.3 Create Service Definition and Service Binding

And then we can preview the published service:

3. Frontend App Development

First create destination on BTP:

Then open BAS service, and choose SAP Fiori Worklist Application:

After publish, and authorization setup, we can see the App like below:

Introducing the New E-learning ‘Clean Core with SAP Business Technology Platform’

2024-04-29T15:06:39.391000+02:00

Clean Core is both a concept and an approach to achieve a modern, flexible, and cloud-compliant ERP system. Clean core is achieved by integration and extending the system in such a way that it is cloud-compliant, with optimal master data quality and perfected business process governance. Leveraging SAP Business Technology Platform enables you to attain clean core compliance, facilitating a smooth and effective digital transformation journey for your business.

The upcoming e-learning course, "Clean Core with SAP Business Technology Platform," offers valuable insights to understand how SAP Business Technology Platform can help cultivate a cleaner and more sustainable core for SAP systems. It offers insights into how SAP BTP can support the fundamental pillars of Data, Integration, and Extensibility.

The e-learning explores the topic of extensibility in-depth and how the various components of SAP Business Technology Platform support the building of extensions in line with clean core principles. This aspect is crucial for businesses looking to adapt and customize their SAP systems without compromising the integrity of their core.

Additionally, the course will advise on the key offerings available to customers through their SAP Enterprise Support, cloud edition subscriptions. This will equip participants with the necessary resources and support to ensure they are using SAP BTP components in line with SAP's clean core strategy.

Please use this link to access the e-learning.

If you have issues accessing the above link, there may be an authorizations issue. Please note a one-time registration in SAP Learning Hub, edition for SAP Enterprise Support, is required. A detailed step-by step guide to registration can be found here.

For internal colleagues, if you cannot access the e-learning, please use the following link, click on “Access” and use the above direct link once access has been granted.

Enroll now and join us as we explore the power of SAP Business Technology Platform in driving a clean core environment for businesses. Get ready to unlock new opportunities and drive innovation with SAP's clean core strategy.

Thanks and Regards,

Sudha Surendran / BTP Architect - SAP Enterprise Support

10+ ways to reshape your SAP landscape with SAP Business Technology Platform - Blog 6

2024-04-30T07:20:00.026000+02:00

Clean Core Extensibility

Here comes the next edition of our blog series “10+ ways to reshape your SAP landscape with SAP Business Technology Platform” – this time the main topic will be extensibility.

Summary:
The extensibility aspect of the SAP Clean Core strategy is one of the most important for many development organisations. To master this aspect knowledge of the technological building blocks, reference architectures and how to tie them together is required. Once an understanding of the possibilities is reached it is important to put this into governance and create a Clean Core Extension strategy. The Application Extension Methodology (AEM) is there to help you achieve this.

Extensibility as a topic is probably as old as SAP systems themselves. Since a standard SAP system represents standard processes and only provides configuration-based changes to those standard processes, the options for adaptation to specific processes are sometimes too limited to achieve the set goal. So far so good and not a problem from the architectural view – extensions have always been and will always be an important part of SAP systems. The problem – as outlined in the previous blog on “How Clean Core can accelerate your SAP Business Transformation” – doesn’t come from wanting to extend the system but how this is done. Through the combination of In-App Extensibility – including Key-User-Tools as well as On-Stack Developer Extensibility – and Side-by-Side Extensibility a Clean Core can be sustained while still realizing business processes through extensions.

As the reasoning should be clear after the previously mentioned blog, this blog will focus on the more technical aspects of such a Clean Core compliant extension. We will look at reference architectures, technological building blocks, resources, where to find them and how to apply them.

References

A lot of software architecture best practices are based on reference architectures. These usually provide a sample along with reasonings and outline options to continue from there. SAP provides a growing number of officially recommended reference architectures for BTP in its Discovery Center. These are fully fledged reference architectures with all needed information. However, you can use other resources as well to find resources from SAP to get an orientation on what others might have implemented or what SAP recommends. In the missions section of the Discovery Center you can search for Clean Core or just browse by topic e.g. Extensibility.

The mentioned resources are part of the SAP BTP Guidance framework which covers not only guidance for architects but also for developers and admins:

Technological Building Blocks

For most cases there’s more than one way to extend a specific functionality in an SAP system. However, not all of them (e.g. a new Dynpro application) comply with the Clean Core paradigm but still it is important to know and find them. Finding them used to be a bigger challenge but fortunately the documentation and coverage in the SAP Business Accelerator Hub has increased immensely and we can find a lot of the previously mentioned resources there. This includes APIs ranging from OData and plain REST all the way to CDS views as well as Events and Integrations. When building a Clean Core compliant extension this is especially useful since we can select our SAP system version and see all standard APIs for it. This works for S/4 systems as well as for all LoB solutions such as SAP SuccessFactors, SAP Concur, SAP Fieldglass, etc. The documented APIs and Events list their status and link to the business documentation, so you know which one to use.

Coming from the implementation side there are two more technical building blocks which make it easier to create Clean Core compliant solutions: CAP and RAP. Both are programming models (Cloud Application Programming Model and RESTful ABAP Programming Model) built and curated by SAP. To cover both non-SAP-experienced and SAP-experienced developers ABAP (RAP) is covered as well as Java and Javascript, the two flavors of CAP. Both models make it a lot easier to create extensions for SAP system using state of the art mechanisms and providing you with the basics for your extension to perfectly integrate into your system landscape. Using the models lets your development focus shift from being able to work with your SAP systems to developing the extension need and business functionality.

An additional factor besides the pro-code-oriented approaches of CAP and RAP are the low-code and no-code tools offered on SAP BTP in the SAP Build Suite. With mostly visual approaches a new developer community can help to realize business functionality while maintain a Clean Core and including them in the process. This can release resources in the IT department and raise satisfaction of business functions since they are more involved.

Tying it all together

Now that we’ve looked at the general possibilities from a technical side (frameworks, tools, APIs, events, …) and an architectural side, it’s time to tie it together and answer the all-important question: When do I use what?

The short answer is that there is no one-size-fits-all solution for this question since it is always dependent on the context ranging from systems and business requirements all the way to existing development resources and personal preference. However, since we know that this is a challenge there’s a toolbox of guidance assets and methodologies to help you answer this question for your organization. Listed in the “Methodologies” section of the SAP BTP Guidance Framework overview you can see three methodologies covering three of the five Clean Core aspects. “Why not all five?” you may ask – the other two aspects also appear in each of the methodologies as a cross concern, so they are covered as well.

Since we’re looking at Extensibility the Application Extension Methodology is our main asset here. The SAP Application Extension Methodology can support and guide you by providing a structured, technology-agnostic approach for customers and partners to define an organization-specific extension strategy. Following this methodology will ensure that everyone in your project uses the same terminology and quickly arrives at a common understanding of the business use case and to-be solution. You’ll have an overview of possible technical extension building blocks and you’ll be able to make an informed decision about your organization’s future extension architecture. After an initial setup the resulting extension framework can be applied to current and future extension projects. This is especially important looking at the aspect of “keep the core clean vs. make the core clean” you read about in Holger’s blog. An extension strategy like this can help you tackle this problem by applying it to new developments and gradually using it with previous developments to bring them up to a Clean Core standard.

Events

To get more insights, please also visit one of our BTP Innovation Days:

Innovation Day Switzerland: Bern 14-May-24 SAP | SAP BTP Innovation Day Switzerland
Innovation Day Germany: Essen 16-May-24 SAP | SAP BTP Innovation Day

SAP S/4HANA Cloud Public Edition ：如何及时发现受影响的项目并采取升级行动？

2024-05-20T09:00:12.130000+02:00

随着数字化转型的加速推进，为提供更多创新的功能和内容，S/4HANA Cloud公有云采取了半年一次的升级和持续功能交付模式。这些变更可能会对客户的自开发项目产生影响，特别是客制化的CDS视图。这意味着客户需要时刻关注系统的变化，并及时采取升级行动。这也给客户带来了挑战。

在本篇博客中，将会探讨一些实用的方法和工具，详细介绍如何帮助客户及时发现受影响的项目，并采取相应的升级行动。

自定义CDS视图

在应用自定义CDS视图内，客户可以创建客制化CDS视图，也可以快速地找到需要及时修改的CDS视图。

进入应用，将过滤器展开，找到“改写”过滤器。该标签为“是”的情况则说明CDS视图需要进行修改。客户还可以根据任务的优先级情况，及时对需要修改的视图采取行动。

打开需要修改的自定义 CDS 视图并进入编辑模式，客户可以获取有关任务以及解决此任务的操作的详细信息。

RASD 2.0/ Release Assessment and Scope Dependency 2.0

Release Assessment and Scope Dependency Tool (RASD) 是一个简单的自学习工具，可帮助客户轻松使用和采用 SAP S/4HANA Cloud 中的影响、改进和创新。

RASD 为客户提供了量身定制的针对每个 S/4HANA Cloud 版本和持续交付的已删除、已弃用、新对象和已更改对象（如应用、API 和 CDS 视图）的列表。该清单根据客户使用和激活的范围进行筛选。客户可以在RASD中快速了解到与其系统/业务相关的变更信息，并做出及时响应。

除了升级会受到的影响外，RASD 还会（根据其范围）向客户显示所有可为其业务或行业增加价值的新功能和改进功能。详细有关于RASD2.0的介绍，可以查看下方链接：

向客户发布的Release Assessment and Scope Dependency Tool (RASD 2.0) 查看

接下来介绍如何在RASD2.0中查找受影响的项目。

使用S-user ID登录RASD2.0，选择想要查看的版本，国家，以及租户等信息。

找到Where Used List 卡片。进入该卡片，可以查看到该版本下收到影响的业务目录以及CDS视图。

尤其是客制化CDS视图，进入该标签，可以查看到系统内受影响的客制化CDS视图。客户可以通过该信息，快速找到受影响的开发项，并根据更改信息及时对开发内容进行修改。

另外值得注意的是，对于三系统架构，RASD2.0目前仅支持查看生产，测试，和开发（Dev100）租户使用情况，若想要查看Dev80的开发项情况，可以使用另外一个工具。

ABAP Test Cockpit

ABAP Test Cockpit（ATC）是一个强大的工具，可以帮助开发人员自动化执行代码质量检查和单元测试，提高ABAP代码的质量和稳定性。ATC直接集成了ABAP Workbench和ADT，客户可以直接在开发环境中检查代码。

因此在开发过程或者升级期间，客户都可以使用 ATC 检查代码，对代码进行及时维护。更多关于ATC的信息，可以参考博文How to configure ABAP Test Cockpit (ATC) in the cloud

接下来主要介绍一下如何在ADT中使用ATC。选中项目，选择Run As -> ABAP Test Cockpit，即可执行对该项目的测试。

执行完后，客户可以在ADT中查看到该项目的执行结果，点击相关的条目可以查看到相关问题的详情。例如下图中可以查看到该项目中使用了已被弃用的CDS视图。客户可以根据提示及时做出响应。

另外在SAP S/4HANA Cloud Public Edition中客户也可以通过“自定义代码迁移”应用，使用ATC检查系统内创建的自定义ABAP代码。

首先需要登录到Development系统Tenant 80。(注意：该应用只有在DEV80中可以使用。) 找到并打开“自定义代码迁移”应用。

若之前未建立过项目，则需要先创建自定义代码分析项目。创建项目中需要维护项目名称，检查变式，以及需要分析的系统。在SAP S/4HANA Cloud Public edition中，待分析系统默认是本系统。

检查变式可选择ABAP_CLOUD_DEVELOPMENT_DEFAULT，该变式包含了SAP ATC建议的所有应执行的检查。

创建完项目并保存后系统会执行代码分析。可以通过刷新，查看最新的分析的状态和进度。然后更改项目范围，可以添加需要检查的package。

代码检查完后，可以切换到分析的板块，查看分析结果，例如可以查看代码中是否使用到了已弃用的对象或元素等。客户可以在升级后，在该应用中快速地对自定义代码进行分析检查，查看升级后代码是否需要维护。

SAP Tech Bytes: SAP S/4HANA Cloud + SAP Integration Suite, AEM + SAP Build Process Automation

2024-05-20T13:25:58.571000+02:00

In this blog post, I share a couple of SAP Tech Bytes on how to enable eventing between SAP S/4HANA Cloud and SAP Build Process Automation via SAP Integration Suite, advanced event mesh. We will configure and trigger events from SAP S/4HANA Cloud, which will then be received by SAP Integration Suite, advanced event mesh, and finally forwarded to SAP Build Process Automation.

Enabling the end-to-end event-driven integration scenario between SAP S/4HANA Cloud and SAP Build Process Automation involves many steps and requires extensive documentation. Sometimes, it might be best to process all that information in video format.

If you're interested in learning how to enable the same scenario using SAP Event Mesh, check out this blog post: https://community.sap.com/t5/technology-blogs-by-sap/sap-tech-bytes-deliver-events-from-sap-eventmesh-to-sap-build-process/ba-p/13574547.

SAP Tech Bytes: Configuring SAP S/4HANA Cloud and SAP Integration Suite, advanced event mesh

Steps shown in the video:

Now that we've configured the communication between SAP S/4HANA Cloud and SAP Integration Suite, advanced event mesh, we can proceed to configure the delivery of events to SAP Build Process Automation.

SAP Tech Bytes: Delivering events from SAP S/4HANA Cloud to SAP Build Process Automation via AEM

Steps shown in the video:

In this SAP Tech Bytes, we’ve seen what’s required to configure eventing between SAP S/4HANA Cloud and SAP Integration Suite, advanced event mesh. Also, we created and configured a REST Delivery Point in AEM in order to forward events to SAP Build Process Automation. The REST Delivery Point functionality is not limited to SAP Build Process Automation; you can also deliver events to other systems that expose an HTTP endpoint to receive them. I hope you enjoy this video on event-driven integration, as there is more to come on this topic in the near future….

Happy eventing!