SAP Community - ABAP Development

How to Control Events on User Decision Before/After the Decision Made

2025-01-03T15:39:05.090000+01:00

Hello everyone,

There was a requirement in a project that the users wants developments before and after the users made their decisions. As the developers we decided to use the program exits in a tab of the User Decision step. In this step we can call a global class and with an interface that I am going to mention below, we can see the workitem details and we can control the start time for our development by the parameters of the interface.

In this blog I will show you how can you use the program exits in the User Decision step and what is the interface for the global class.

1. Where is the program exit and how we use it.

The program exits are in the steps of workflows that we create task inside like User Decision, Activity, Send Mail etc. I will continue on User Decision step so we can see how to control decisions before and after made.

When we double click on User Decision step we can see the Program Exits tab as show below.

We need to create a Z Class and give the interface IF_SWF_IFS_WORKITEM_EXIT in the class.

1.1 How we can have benefit from the Interfaces?

There are two parameters of that interface which is; IM_EVENT_NAME and IM_WORKITEM_CONTEXT.

We can reach when the class is triggered by the IM_EVENT_NAME.

IM_EVENT_NAME contains the domain values as below;

BEF_CREAT Before Creation
CREATED After Creation
BEF_EXEC Before Execution
AFT_EXEC After Execution
AFT_ASYINV After Execution of a Synchronous Object Method
BEF_REMOVE Before Physical Deletion
STATE_CHG After a Status Change
AFT_REXEC After Rule Execution
AFT_ACTION After an Action
BEF_ACTION Before an Action
BEF_DECI Before Execution of a User Decision

IM_WORKITEM_CONTEXT contains another interface which is IF_WAPI_WORKITEM_CONTEXT and there are many methods that we can use for our cases.

1.2 Create your Z Class

Create a global class and give the interface to it. By doing that you will be able to reach the method EVENT_RAISED.

Make your coding inside the method and don't forget to control it by IM_EVENT_NAME.

2. Trigger The Workflow

Now we all set. Trigger your workflow by your process. Once the workflow is triggered it can be seen from transaction SWIA.

3. How can we debug the method?

When the workflow reaches the step that you implemented a program exit, the class is triggered and by the IM_EVENT_NAME we can check the time we want to control.

Place an external debug for user SAP_WFRT in the EVENT_RAISED method of Z class.

3. Find the Parameters You Need

When we are in the debug we can see the parameters as below and every step of user decision the IM_EVENT_NAME will be changed.

In the IN_WORKITEM_CONTEXT You can reach the Node ID and Task ID clearly. And inside the M_CONTAINER we can reach the Workitem ID(WI_ID).

By calling the GET_WI_CONTAINER method of the IM_WORKITEM_CONTEXT parameter we can reach the container elements that we send to the user decision.

The container elements will be shown in the MT_ELEMENTS tab.

Conclusion :

Now you can design your workflow and check the steps of the User Decision if it's on the after creation, before execution etc. and make your development.

Thanks for your time.

If you think this blog is helpful please do not forget to like and share. 🙂

Switching from ALV GUI to List Report Fiori RESTful Abap Programming is now easy

2025-01-03T15:44:27.909000+01:00

List report read-only

In this topic will create a simple Fiori List Report without object page. It's recommended to use odata v4 but here we will create both v2 and v4

CDS Model

The CDS model is driven by the VDM(Virtual data model) which follow consistent modeling and naming rules.

View entity Basics/Composites

Create new data definition language in ADT(need eclipse 😀 )

DDIC view based are obsoletes, so we only use view entity.

We don't use table directly beceause it's not clean core, instead we use release CDS, you can see this if they are flagged with "#PUBLIC_LOCAL_API" or release C1 contract in API State.

Now fill your new CDS :

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'CDS basic purchase orders'
define view entity ZI_MyPurchaseOrders
  as select from I_PurchaseOrderAPI01
{
  key PurchaseOrder,
      PurchaseOrderType,
      PurchaseOrderSubtype,
      PurchasingDocumentOrigin,
      CreatedByUser,
      CreationDate,
      PurchaseOrderDate,
      CashDiscount1Percent,
      CashDiscount1Days,
      @Semantics.amount.currencyCode: 'DocumentCurrency'
      DownPaymentAmount,
      DocumentCurrency

}

Compile your CDS, and if you want you can add documentation :

Now you can fill your own documentation

And if you refresh your CDS you can open your documentation or if you press F2 on your object you can see documentation with definition

Now we will create our root view entity but you can also create other CDS levels between the two.

The root view entity is the last level before projection view. We'll go into more detail in the object section on page

You can use the code below

@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'CDS root purchase orders'
define root view entity ZR_MyPurchaseOrders
  as select from ZI_MyPurchaseOrders
{
  key PurchaseOrder,
      PurchaseOrderType,
      PurchaseOrderSubtype,
      PurchasingDocumentOrigin,
      CreatedByUser,
      CreationDate,
      PurchaseOrderDate,
      CashDiscount1Percent,
      CashDiscount1Days,
      DownPaymentAmount,
      DocumentCurrency
}

Compile

View entity Projection View

Now you need to create the top level view. Only the fields you have in this view can be displayed.

@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'CDS Projection view Purchase Orders'
define root view entity ZC_MYPURCHASEORDERS
  provider contract transactional_query
  as projection on ZR_MyPurchaseOrders
{
  key PurchaseOrder,
      PurchaseOrderType,
      PurchaseOrderSubtype,
      PurchasingDocumentOrigin,
      CreatedByUser,
      CreationDate,
      PurchaseOrderDate,
      CashDiscount1Percent,
      CashDiscount1Days,
      DownPaymentAmount,
      DocumentCurrency
}

As you're pointing to a root cds view, you need to specify the root instruction in the projection view too.

Also you need to provide a contract, for our example it's "transactional_query", you can bypass this but it's not recommended.

Compile

Metadata Extension

The metadata extension is used to arrange elements on the UI application with annotations. You can have multiple levels of metadata extension.

Add fields position in table

By default, no fields will be displayed. To achieve this, we're going to add annotations at the CDS level (where they can also be added in the frontend application).

So firstly you need to add this annotation in your projection view

@Metadata.allowExtensions: true

Then to add a field in first position you'll use this annotation

"""Metadata extension """
@UI.lineItem: [{ position: 10 },{ importance: #HIGH }]

Increment from 10 to 10 to make reworking easier if you've got a position wrong.

Add selection fields(filters) position in table

"""Metadata extension """
@UI.selectionField: [{ position: 10 }]

Add value helps

To add value helps your have two options, one with relationship with foreign key and the second with cds view

We focus only on the second option. To do this, we'll need a cds view of type value help, which we'll call up and which will return all the values in the database.

@Consumption.valueHelpDefinition: [{ entity : {name: '/DMO/I_AGENCY_STDVH', element: 'AgencyID'  } }]

Create and fill your metadata extension

Now that we have the three default annotations for a correct list report, we can get started.

Then you can choose to annotate entity or view.

Choose view for example

Now the aim is to add annotations for every field you want

@Metadata.layer: #CUSTOMER
@UI: {
    headerInfo: {
        typeName: 'Purchase Order',
        typeNamePlural: 'Purchase Orders'
    },
    presentationVariant: [{
        sortOrder: [{
            by: 'PurchaseOrder',
            direction: #DESC
        }],
        visualizations: [{
            type: #AS_LINEITEM
        }]
    }]
}
@Search.searchable: true
annotate view ZC_MYPURCHASEORDERS with
{
@UI.lineItem: [{ position: 10 },{ importance: #HIGH }]
@UI.selectionField: [{ position: 10 }]
@Search.defaultSearchElement: true
@Search.fuzzinessThreshold: 0.8
PurchaseOrder;
@UI.lineItem: [{ position: 20 },{ importance: #HIGH }]
@UI.selectionField: [{ position: 20 }]
@Search.defaultSearchElement: true
@Search.fuzzinessThreshold: 0.8
@Consumption.valueHelpDefinition: [{ entity : {name: 'I_PurchasingDocumentType', element: 'PurchasingDocumentType'  } }]
PurchaseOrderType;
@UI.lineItem: [{ position: 30 }]
@UI.selectionField: [{ position: 30 }]
@Search.defaultSearchElement: true
@Search.fuzzinessThreshold: 0.8
PurchaseOrderSubtype;
@UI.lineItem: [{ position: 40 }]
@UI.selectionField: [{ position: 40 }]
@Search.defaultSearchElement: true
@Search.fuzzinessThreshold: 0.8
PurchasingDocumentOrigin;
@UI.lineItem: [{ position: 50 }]
@UI.selectionField: [{ position: 50 }]
CreatedByUser;
@UI.lineItem: [{ position: 60 }]
@UI.selectionField: [{ position: 60 }]
CreationDate;
@UI.lineItem: [{ position: 70 }]
@UI.selectionField: [{ position: 70 }]
PurchaseOrderDate;
@UI.lineItem: [{ position: 80 }]
@UI.selectionField: [{ position: 80 }]
CashDiscount1Percent;
@UI.lineItem: [{ position: 90 }]
@UI.selectionField: [{ position: 90 }]
CashDiscount1Days;
@UI.lineItem: [{ position: 100 }]
@UI.selectionField: [{ position: 100 }]
DownPaymentAmount;
@UI.lineItem: [{ position: 110 }]
@UI.selectionField: [{ position: 110 }]
DocumentCurrency;
}

Business Services

Now we will define entities and create odata service

Service Definition

Create new Service Definition

Insert the code below

@EndUserText.label: 'Service definition for ZC_MYPURCHASEORDERS'
define service ZUI_MYPURCHORDERS {
  expose ZC_MYPURCHASEORDERS as PurchaseOrders;
}

Don't forget to alias your entities

Service Binding

Now we'll create our odata service. Here's how to create an odata v2 and v4 service.

You need to activate your service binding (ctrl+f3)

Now you have two way to activate your odata service, use the publish button BUT it's only for testing because the input will be local and cannot be put into a package, or use the t-code /IWFND/V4_ADMIN to transport it in package.

I advise you to check that there are no errors with the publish option in service binding, as you can sometimes get errors with conversion routines (which are not allowed in view entities with 3 exceptions). Once ok, you can unpublish it and then republish it with the transaction for productive use.

Now your odata V4 is ready to use.

For V2 it's the same logic but for productivity you need to activate with t-code /IWFND/MAINT_SERVICE

Access control (DCL)

If you want to add authorization objects in this application, you can add access control. For example if you want restrict purchase order type with PFCG object. Once you've created your odata service, you'll need to add the authorization objects used in access control in su24.

Make sure you have enabled authorization control on the root view

@AccessControl.authorizationCheck: #CHECK

Create DCL(Access Control) for root view entity :

Then insert the code below

@EndUserText.label: 'Access control for ZR_MYPURCHASEORDERS'
@MappingRole: true
define role ZR_MYPURCHASEORDERS {
    grant 
        select
            on
                ZR_MYPURCHASEORDERS
                    where ( PurchaseOrderType ) = aspect pfcg_auth ( M_BEST_BSA,BSART,actvt = '03' );
                        
}

And of course, if you want to use your own specific authorization object, that's also possible.

Now create another DCL(Access Control) for projection view. This DCL will only inherit the DCL of the root view.

Make sure you have enabled authorization control on the projection view

@AccessControl.authorizationCheck: #CHECK

Insert the below code

@EndUserText.label: 'Access control for ZC_MYPURCHASEORDERS'
@MappingRole: true
define role ZC_MYPURCHASEORDERS {
    grant
        select
            on
                ZC_MYPURCHASEORDERS
                    where
                        inheriting conditions from entity ZR_MyPurchaseOrders;
                        
}

Now you just need to add yours authorizations objects in your odata service with t-code SU24, and create role in PFCG and assign to you or users.

Fiori Element

Open Business Application Studio or VScode(with configured Fiori tools extension).

Launch "Fiori open application generator" with command palette(ctrl+shift+p)

Select Fiori Element List report and select your system, odata service,project name, options

Now your app is ready to test.

You'll notice that by default it has added a navigation in manifest.json to an object page that we haven't coded in the CDS views. We'll set this aside.

    },
        "PurchaseOrdersObjectPage": {
          "type": "Component",
          "id": "PurchaseOrdersObjectPage",
          "name": "sap.fe.templates.ObjectPage",
          "options": {
            "settings": {
              "editableHeaderContent": false,
              "contextPath": "/PurchaseOrders"
            }
          }
        }

Test your app with command

npm run start

You can also test your value help in purchase order type

And congrats, you've got a simple List Report application that respects the new development standards.

Of course, this display is very simplistic as we've added very few features, so feel free to dig deeper. You can also extend your application to add a custom filter or a new column. And if the design of the lists reports doesn't suit your needs you can always go for FPM and even freestyle(but no longer recommended 😀 )

Technical Catalog

If you want to deploy for an Private Cloud/On-Premise system in the Fiori Launchpad, you need to create at least a technical catalog. To do this create your catalog in t-code /UI2/FLPAM an fill your Fiori application technical data(no longer use launchpad designer please)

Next steps

The next step is to deploy your application on your SAP system. To do this, you'll need to run the deployment configuration (npm run deploy-config). Also you may need to fill in the object page and we'll look at that in a second part. And why not show how to add an action with behavior definition(BDEF).

IDoc Failure and Resolution in SAP

2025-01-04T09:15:54.686000+01:00

IDocs (Intermediate Documents) in SAP are used for Electronic Data Interchange (EDI) to exchange data between SAP and external systems. However, IDoc processing can encounter errors resulting in failures. Here's a breakdown of IDoc failures and their resolution process, along with an example:

**IDoc Failure:**

An IDoc failure occurs when there's an issue during data exchange, preventing successful transfer of information. This can happen due to various reasons:

* **Data Mapping Errors:** Incorrect mapping between SAP data fields and the external system's format.
* **Missing or Invalid Data:** Required data fields missing in the IDoc or containing invalid values.
* **Communication Issues:** Network connectivity problems between SAP and the external system.
* **Application Errors:** Errors in the receiving application logic causing processing issues.

**Resolving IDoc Failures:**

Here's a general process for resolving IDoc failures:

1. **Identify the Error:** Use transaction WE05 (Display IDoc) to check the IDoc status and error message. The message provides details about the cause of the failure.
2. **Analyze the Error:** Based on the error message, pinpoint the root cause (data mapping, missing data, etc.).
3. **Resolve the Issue:**
* Fix data mapping errors in the configuration.
* Correct missing or invalid data in the originating document.
* Troubleshoot network connectivity issues.
* Work with the application team to address application-specific errors.
4. **Reprocess the IDoc:** Once the issue is resolved, use transaction WE19 (Reprocess IDoc) to attempt processing the IDoc again.

**Example:**

An IDoc for a sales order fails with an error message indicating a missing customer number. The resolution steps might involve:

* Checking the originating sales order in transaction VA01.
* Verifying if the customer number is missing or incorrect.
* Updating the customer number in the sales order.
* Reprocessing the IDoc using WE19.

**Additional Tips:**

* Use transaction SM37 (Job Overview) to monitor background jobs related to IDoc processing.
* Leverage table EDIDS to track IDoc statuses and detailed error logs.
* For complex errors, consider involving SAP Basis or EDI specialists for further assistance.

By following these steps and understanding the potential causes of IDoc failures, you can effectively troubleshoot and resolve issues to ensure smooth data exchange between SAP and external systems.

Defining Local Fields in SAP QUERY

2025-01-04T09:20:52.090000+01:00

Local Fields in SAP Query: Enhancing Reporting Flexibility

Local fields in SAP Query are calculated fields that you define within the query itself. They don't exist in the underlying database tables or InfoSet. This allows you to perform calculations, transformations, or logical operations on existing fields without needing to create new fields in the database. This is very useful for reporting purposes.

Key Benefits of Local Fields:

Flexibility: Create custom calculations and derive new information without modifying the underlying data structure.
Performance: Calculations are performed during query execution, avoiding the need to store redundant data.
Simplicity: Define complex logic directly within the query, making it easier to manage and maintain.

Example: Calculating Delivery Variance (Your Scenario)

Let's use your example of the BACKLOGVENTES InfoSet to illustrate how to define a local field for delivery variance:

Scenario: You want to see the difference between the referenced quantity (DELIVERY) and the confirmed quantity (SALES ORDER). This difference represents the delivery variance.

Steps to Define a Local Field:

Open SAP Query (SQ01/SQ02): Navigate to SAP Query using transaction codes SQ01 (Queries) or SQ02 (InfoSets).
Edit/Create a Query: Open the relevant query based on the BACKLOGVENTES InfoSet.
Go to the "Fields" tab: This is where you select the fields to be included in your report.
Define a Local Field:
- Click on the "Local Fields" button (usually represented by an icon of a calculator or a field with a plus sign).
- Enter a name for your local field (e.g., DELIVERY_VARIANCE).
- Enter a description (e.g., "Difference between Referenced and Confirmed Quantity").
- Crucially, enter the formula: This is where you define the calculation. In your case, the formula would be:
  DELIVERY - SALES_ORDER
  (Assuming DELIVERY represents the "Referenced quantity in base unit of measure" and SALES_ORDER represents the "Confirmed Quantity". Adjust the field names to match your InfoSet.)
- Specify the data type and length of the local field, if necessary. Usually, the query tool infers this based on the formula.
Add the Local Field to the Output: Select the newly created local field (DELIVERY_VARIANCE) to be included in your report output.
Execute the Query: Run the query to see the results, including the calculated delivery variance.

Example in More Detail (with potential field names):

Let's say the actual field names in your InfoSet are:

VBAP-KWMENG (Confirmed Quantity in Sales Order - often aliased as SALES_ORDER in the Infoset)
LIPS-LFIMG (Delivered Quantity / Referenced Quantity in delivery - often aliased as DELIVERY)

Then, your local field definition would be:

Name: DELIVERY_VARIANCE
Description: "Difference between Delivered and Confirmed Quantity"
Formula: LIPS-LFIMG - VBAP-KWMENG or DELIVERY - SALES_ORDER (depending on how the fields are aliased in your InfoSet)

Important Considerations:

Data Types: Ensure the data types of the fields used in the formula are compatible. You might need to use type conversions (e.g., NUMC to DEC) if necessary.
Aliases: If your InfoSet uses aliases for field names, use the aliases in your formula.
Error Handling: Consider potential errors, such as dividing by zero. You can use conditional statements (e.g., IF...THEN...ELSE) to handle these cases.

By using local fields effectively, you can create powerful and flexible reports in SAP Query without needing to modify the underlying data structure, making reporting much easier and more efficient.

12 Tips for Beginners Starting with SAP ABAP Programming

2025-01-05T03:58:59.961000+01:00

Welcome to Our SAP ABAP Programming Guide!

Are you starting your journey into the world of SAP ABAP programming? You've come to the right place! In this post, we’ve compiled 12 essential tips to help you navigate the initial steps of learning ABAP. Whether you're a complete beginner or have some basic knowledge, these tips will provide you with a solid foundation to build your skills.

12 Tips for Beginners Starting with SAP ABAP Programming

1. Understand the Basics of SAP
Before diving into ABAP, familiarize yourself with the fundamentals of SAP. Learn about SAP modules, the ERP system, and how different components interact.

2. Learn the Syntax and Structure
Start by understanding the basic syntax and structure of ABAP. Get comfortable with keywords, data types, and basic programming constructs.

3. Use the ABAP Development Tools (ADT)
Get accustomed to using ABAP Development Tools in Eclipse. It’s essential for efficient development and offers features like syntax highlighting, code completion, and debugging tools.

4. Understand Data Dictionary Objects
Learn how to work with Data Dictionary (DDIC) objects such as tables, views, data elements, and domains. These are crucial for database interactions in ABAP.

5. Practice Modularization Techniques
Master the use of subroutines, function modules, methods, and classes to write modular and reusable code. This will make your programs more maintainable and efficient.

6. Get Familiar with Internal Tables
Internal tables are a key feature in ABAP for handling data in-memory. Practice creating, populating, and manipulating internal tables.

7. Understand ALV Reports
Learn how to create and customize ALV (ABAP List Viewer) reports. ALV provides a flexible way to output data with features like sorting, filtering, and layout customization.

8. Explore Open SQL
SAP ABAP uses Open SQL for database operations. Learn the basics of SELECT, INSERT, UPDATE, and DELETE statements, and how to handle database transactions.

9. Practice Debugging
Get comfortable with the debugging tools in ABAP. Knowing how to effectively debug your code is crucial for identifying and fixing issues.

10. Learn About BAPIs and RFCs
BAPIs (Business Application Programming Interfaces) and RFCs (Remote Function Calls) are essential for integrating different SAP systems. Understand how to use them to enable communication between systems.

11. Get Hands-On with Enhancements and Exits
Learn about user exits, BADI (Business Add-Ins), and enhancement spots to customize and extend standard SAP functionality.

12. Engage with the SAP Community
Join the SAP community through forums, blogs, and SAP’s official website. Engaging with experienced professionals can provide valuable insights and help you stay updated with the latest developments.

Writing Clean Code and Best Practices in SAP ABAP

2025-01-06T16:12:50.402000+01:00

Clean code is not just about writing code that works; it's about writing code that is readable, maintainable, and efficient. In the context of SAP ABAP, adhering to clean code principles and best practices can significantly enhance the quality of your programs. Here are some key points to keep in mind:

1. Use Meaningful Names
Choose clear, descriptive names for variables, methods, and classes. Avoid abbreviations and aim for names that convey the purpose and intent of the code.

2. Write Small and Focused Methods
Keep your methods small and focused on a single task. This makes the code easier to understand, test, and maintain. Aim for methods that do one thing and do it well.

3. Avoid Hardcoding Values
Hardcoding values makes the code inflexible and harder to maintain. Use constants or configuration tables instead, so changes can be made easily without modifying the code.

4. Comment Judiciously
Write comments that explain why a piece of code exists, not what it does. Good code should be self-explanatory, but comments can provide context and rationale for complex logic.

5. Follow Consistent Formatting
Maintain a consistent coding style and format throughout your ABAP programs. This includes indentation, spacing, and naming conventions. Consistent formatting improves readability and helps in code reviews.

6. Use Modularization Techniques
Break down complex processes into smaller, reusable components using subroutines, function modules, or methods. Modularization promotes code reuse and simplifies debugging.

7. Handle Exceptions Properly
Implement proper error handling using TRY-CATCH blocks. Ensure that your code gracefully handles exceptions and provides meaningful error messages to users.

8. Optimize Database Access
Minimize the number of database accesses and use efficient queries. Retrieve only the data you need and avoid nested SELECT statements. Use indexes and buffering where appropriate.

9. Avoid Using Obsolete Constructs
Stay updated with the latest ABAP syntax and features. Avoid using obsolete constructs and embrace modern ABAP features such as inline declarations, new string operations, and expressions.

10. Test Your Code Thoroughly
Write unit tests to validate your code's functionality. Regular testing helps catch bugs early and ensures that your code behaves as expected in different scenarios.

11. Document Your Code
Provide clear and concise documentation for your programs. This includes explaining the purpose, usage, and any special considerations of your code. Good documentation aids future maintenance and onboarding of new developers.

12. Engage in Code Reviews
Participate in code reviews to share knowledge and ensure adherence to coding standards. Peer reviews help identify potential issues and foster a culture of continuous improvement.

By following these clean code principles and best practices, you can create ABAP programs that are robust, efficient, and easy to maintain. Clean code is a key factor in the long-term success of any software project, and SAP ABAP is no exception.

Manual Assignment of Loading and Truck Resource to FO

2025-01-07T09:23:17.911000+01:00

Hi All,

I would like to share my working experience on custom development for Transportation Management Optimization, SAP has already provided standard Fiori app to perform optimization, however we don't have any GUI based single step solution to perform optimization in TM.

Requirement: We received requirement from business team, to design simple SAP ABAP program to perform TM Optimization automation. based on inputs: Freight Unit, Sending Location, Receiving location, Planning Profile.

Pre-requisite: ABAP Development and BOBF Development and functional skills needed to perform above activity.

Following are the process steps:

An Automatic Freight Unit is created in SAP TM, from an ERP STO document.
Transportation Planning is performed and Freight Order is created from FU document.
Transportation planning utilizes the optimizer engines like – TVSR/ VSR (Vehicle Resource Scheduling) and assigns a truck resource and loading resource to the Freight Order, according to the input variables from Freight Unit document.
But, in case there is no loading slot available, enough to accommodate the loading activity of the Freight Order or, there is no available truck resource during the FU -> pick up window date/ time, then a manual planning is performed in the Transportation Cockpit window.
But, in manual planning, only a truck resource is assigned not the loading resource.
For the resolution for this business requirement, a custom manual optimization button is created, which would assign an appropriate truck resource (truck having 100% utilization for the selected FU) and a loading resource is assigned according to the prioritized sequence for the loading plant and product combination.
First FO document is created against the FU, by selecting the FU and calling the standard action of the business object – TOR -> sub-node - STOP_SUCC -> action - AUTOPLAN_STAGE.
Above action will create a Freight Order and assign it to the Freight Unit.
Afterwards, select the newly created FO and call the action -> ASSIGN_VEHICLE_RES for assigning the truck resource at BO – TOR -> sub-node – ROOT.
Once the truck resource is assigned, loading/ handling resource can be assigned to this Freight Order, with start load time, similar to FU pick up window start date/ time. Further 15 mins. of loading time is ended in start date/ time leading to load end date/ time.
This would complete the manual optimization process, with a single button.

Logic: Get the all fright unit DB keys from the from the Transparent Table /SCMTMS/D_TORROT based on Document, pass all the DB keys to helper class /scmtms/cl_tor_helper_read method GET_TOR_DATA to read Logistical Stop Successor Stage data

/scmtms/cl_tor_helper_read=>get_tor_data(
  EXPORTING
    it_root_key                     =  int_key                " Key Table
  IMPORTING
    et_stop_succ                   = DATA(int_stop_succ)      " Logistical Stop Successor = Stage
).

Using these data, get the Planning Profile data /SCMTMS/D_PLAPRO and call standard action from freight unit -> AUTOPLAN_STAGE

"Get instance of service manager TOR
DATA(lo_tor_srvmgr) = /bobf/cl_tra_serv_mgr_factory=>get_service_manager( /scmtms/if_tor_c=>sc_bo_key ).
"Get instance for transaction manager
CALL METHOD /bobf/cl_tra_trans_mgr_factory=>get_transaction_manager
  RECEIVING
    eo_transaction_manager = DATA(lo_txn_mgr). " Standalone Transaction Manager Instance
CREATE DATA lr_create_capa_param.

SELECT SINGLE * INTO (wa_plapro) FROM /scmtms/d_plapro WHERE profile_id = @p_pro.

IF sy-subrc  = 0.
  MOVE-CORRESPONDING wa_plapro TO lr_create_capa_param->plan_prof  .
ENDIF.
TRY.
    "Call action From FU -> STOP_SUCC -> AUTOPLAN_STAGE action
    lo_tor_srvmgr->do_action(
      EXPORTING
          iv_act_key           = /scmtms/if_tor_c=>sc_action-stop_successor-autoplan_stage
          it_key               = int_fo_key
          is_parameters        = lr_create_capa_param
      IMPORTING
          eo_change                = DATA(lo_change)
          eo_message               = DATA(fo_message)
          et_failed_key            = DATA(lt_failed_key)
          et_failed_action_key     = DATA(lt_failed_action_key)
          ev_static_action_failed  = DATA(int_static_action_failed)
          et_data                  = lt_tor_root
          et_data_link             = DATA(int_data_link)
    ).
  CATCH /bobf/cx_frw_contrct_violation INTO DATA(lx_exc). " Caller violates a BOPF contract
ENDTRY.

lo_txn_mgr->save(
  IMPORTING
    ev_rejected = DATA(lv_re)            " Data element for domain BOOLE: TRUE (='X') and FALSE (=' ')
    eo_message  = fo_message                " Interface for transaction change objects
).

After saving the action, Now get the freight order details against freight unit /SCMTMS/D_TORITE inner join /SCMTMS/D_TORROT

"Get Freight Order aginst Freight Unit number
SELECT SINGLE b~db_key, b~tor_id, a~gro_vol_val, a~src_loc_keytrq, a~des_loc_keytrq
   INTO (wa_tor_fo)
   FROM /scmtms/d_torite AS a
   INNER JOIN /scmtms/d_torrot AS b
   ON a~parent_key = b~db_key
   WHERE a~fu_root_key = _tor_fu_key
   AND a~item_cat = 'PRD'
   AND b~tor_cat = 'TO'.

Assign vehicle to the freight order: Action For Assign Truck Resource to Freight Order.
If the Truck Resource ID is Available the perform the action to assign.

          "  action – ASSIGN_VEHICLE_RES, on Freight Order object – ROOT node, with VEH_KEY as TMSRESUID
          lo_tor_srvmgr->do_action(
            EXPORTING
              iv_act_key    = /scmtms/if_tor_c=>sc_action-root-assign_vehicle_res
              it_key        = int_fo_key
              is_parameters = lr_assign_vehicle_res
            IMPORTING
              eo_change     = lo_change
              eo_message    = fo_message
              et_failed_key = lt_failed_key
          ).

          lo_txn_mgr->save(
            IMPORTING
              ev_rejected = lv_re            " Data element for domain BOOLE: TRUE (='X') and FALSE (=' ')
              eo_message  = fo_message       " Interface for transaction change objects
          ).

If The Truck Resource ID in Not Available the Perform the action which will cancel the,
Created Fright order against the Selected Freight Unit.

*-- Action to Cancle Frieght Order
          CALL METHOD lo_tor_srvmgr->do_action
            EXPORTING
              iv_act_key    = /scmtms/if_tor_c=>sc_action-root- remove_tor_assignments
              it_key        = int_fo_key
            IMPORTING
              eo_change     = lo_change
              eo_message    = fo_message
              et_failed_key = lt_failed_key.

          lo_txn_mgr->save(
            IMPORTING
              ev_rejected = lv_re            " Data element for domain BOOLE: TRUE (='X') and FALSE (=' ')
              eo_message  = fo_message       " Interface for transaction change objects
          ).
*-- Display Message
          MESSAGE: TEXT-184 TYPE 'S' DISPLAY LIKE 'E'.
          EXIT.

Once the truck resource is assigned, loading/ handling resource can be assigned to this Freight Order, with start load time, similar to FU pick up window start date/ time. Further 15 mins. of loading time is ended in start date/ time leading to load end date/ time.

       " get all the stop and root data for freight order
        CLEAR: int_stop_key[].
        SELECT db_key INTO TABLE @int_stop_key FROM /scmtms/d_torstp WHERE parent_key = _tor_fo-db_key.

        lo_tor_srvmgr->retrieve(
          EXPORTING
            iv_node_key = /scmtms/if_tor_c=>sc_node-stop
            it_key      = int_stop_key
          IMPORTING
            et_data     = int_fo_stop ).


        "now set the indicator based on which action we are calling
        LOOP AT int_fo_stop ASSIGNING FIELD-SYMBOL(<fs_fo_stop>) WHERE stop_cat = 'O'.
          <fs_fo_stop>-assgn_hres = wl_handling_res.
          <fs_fo_stop>-assgn_hres_cons = '1'.

          CONVERT TIME STAMP <fs_fo_stop>-aggr_assgn_start_l TIME ZONE 'UTC' INTO DATE wf_input_date TIME wf_input_time.
          wl_duration = wl_fix_dur.
          wf_hours =   wl_duration+0(2).
          wf_minutes = wl_duration+2(2).
          wf_seconds = wl_duration+4(2).

          CALL FUNCTION 'IGN_TIMESTAMP_PLUSMINUS'
            EXPORTING
              start_date  = wf_input_date
              start_time  = wf_input_time
              forward     = abap_false
              backward    = abap_true
              hours       = wf_hours
              minutes     = wf_minutes
              seconds     = wf_seconds
            IMPORTING
              result_date = wf_output_date
              result_time = wf_output_time.
          IF sy-subrc = 0.
            <fs_fo_stop>-aggr_assgn_start_l = wf_output_date && wf_output_time.
          ENDIF.
        ENDLOOP.

        INSERT /scmtms/if_tor_c=>sc_node_attribute-stop-assgn_hres      INTO TABLE int_chg_fields.
        INSERT /scmtms/if_tor_c=>sc_node_attribute-stop-assgn_hres_cons INTO TABLE int_chg_fields.
        INSERT /scmtms/if_tor_c=>sc_node_attribute-stop-aggr_assgn_start_l INTO TABLE int_chg_fields.

        /scmtms/cl_mod_helper=>mod_update_multi(
          EXPORTING
            it_data           = int_fo_stop
            iv_node           = /scmtms/if_tor_c=>sc_node-stop
            iv_bo_key         = /scmtms/if_tor_c=>sc_bo_key
            it_changed_fields = int_chg_fields
          CHANGING
            ct_mod            = int_mod ).

        lo_tor_srvmgr->modify(
          EXPORTING
            it_modification = int_mod ).

        lo_txn_mgr->save(
          IMPORTING
            ev_rejected = lv_re            " Data element for domain BOOLE: TRUE (='X') and FALSE (=' ')
            eo_message  = fo_message       " Interface for transaction change objects
        ).

Display success message from the standard messages.

ABAP LLM Client Beta Release

2025-01-08T10:10:58.336000+01:00

Following the alpha preview announcement, I'm excited to share that ABAP LLM Client has reached its beta milestone with version 0.1.0. This release brings several significant improvements and new features that make LLM integration in ABAP easier to use.

What's New in Beta

Enhanced Provider Support

Added Azure OpenAI Services support
Existing integrations with OpenAI, OLLAMA, and OpenRouter improved

Improved Security

Implemented SSF-based secret encryption
New BAdI interfaces for custom security implementations, authorization checks, and more
Flexible architecture allowing easy integration of your security requirements

Tool (Function call) Support

Added support for tool calls
Enhanced configuration options

Developer Experience

Streamlined API design for more intuitive usage
Reduced complexity
Documentation for quick start

Looking Ahead

While this beta release marks a significant milestone, it's important to note that this client serves as a foundation for more exciting developments to come.

Getting Started

Visit the GitHub repository to:

Access installation instructions
Review documentation
Explore example implementations
Provide feedback or report issues

Stay tuned for upcoming announcements about new projects building upon this foundation!

CDS Views 7.5x Quick Reference

2025-01-09T07:55:43.926000+01:00

Introduction

This Quick Reference is a collection of new CDS functionality made available in ABAP 7.5x releases. This functionality is summarised in a way that will make sense to those familiar with SAP CDS. Links to the SAP Help are also provided throughout to allow the reader to dive in deeper if desired. The version the functionality was released is also given to aid in determining if it is available in your system.

S/4HANA	1511	1610	1709	1809	1909	2020	2021	2022	2023
ABAP	7.50	7.51	7.52	7.53	7.54	7.55	7.56	7.57	7.58

Contents

CDS View Entity
CDS Abstract Entity
CDS Custom Entity
CDS Projection views
CDS Access Controls

1. CDS View Entity (7.50)

Syntax

[@enity_annot1]
[@entity_annot2]
...
[@view_entity_annot1]
[@view_entity_annot2]
...
[DEFINE] [ROOT] VIEW ENTITY view_entity
[parameter_list]
AS select_statement [;]...

Description

CDS view entities are non DDIC-based views. While they were introduced in 7.50 the old DDIC-based views (DEFINE VIEW ddic_based_view) only became obsolete in 7.56.

Extensions

EXTEND VIEW ENTITY (7.55)

Makes it possible to add new view fields to existing CDS view entities and CDS projection views by using CDS view entity extensions.

EXTEND VIEW ENTITY cds_view_entity | projection_view
       WITH
            [association1
             association2 ...]
            { select_list_extension }
            [GROUP BY field1, field2, ...  ]
            [EXCEPT | INTERSECT | UNION [ALL]  { ... }] [;]

ANNOTATE ENTITY (7.53)

Define CDS metadata extensions(type:DDLX) for any CDS entities with the exception of CDS table functions.

@Metadata.layer: #CORE|#LOCALIZATION|#INDUSTRY|#PARTNER|#CUSTOMER
   [@entity_annot1]
   [@entity_annot2]
   ...
   ANNOTATE ENTITY cds_entity WITH
     [ parameter_list]
     { [element_list] }[;]

Set Operators

UNION (7.56)

Now supported in CDS view entities.

EXCEPT (7.56)

Returns all rows of a SELECT statement that are not part of the result sets of the following SELECT statements.

INTERSECT (7.56)

Returns all distinct rows that are included in all result sets of multiple SELECT statements.

Functions

GET_NUMERIC_VALUE (7.56)

Conversion Function. Returns the numeric value of a currency or quantity without its currency or unit key.

  key carrid,
  key connid,
  key fldate,
      @Semantics.amount.currencyCode: 'currency'
      price,
      currency,
      @Semantics.amount.currencyCode: 'currency'
      paymentsum,
      GET_NUMERIC_VALUE( paymentsum )  / GET_NUMERIC_VALUE( price )
                as number_of_bookings

CURR_TO_DECFLOAT_AMOUNT (7.56)

Conversion Function. Converts the function argument(must have data type CURR and a currency key ) into a type DECFLOAT34.

  key id,
      cuky                              as currency,
      @Semantics.amount.currencyCode: 'currency'
      curr10_4                          as amount,
      @Semantics.amount.currencyCode: 'currency'
      CURR_TO_DECFLOAT_AMOUNT(curr10_4) as curr_conv

SUBSTRING (7.57)

Function enhanced to accept literals, fields, parameters, expressions, and built-in functions as arguments pos and len.

SUBSTRING(arg, pos, len) Substring arg from the position pos with length len.

LEFT and RIGHT (7.57)

Functions enhanced to accept literals, fields, parameters, expressions, and built-in functions as argument len.

LEFT(arg, len) String of the length len with the len left characters of arg (ignoring the trailing blanks).

RIGHT(arg,len) String of the length len with the len right characters of arg (ignoring the trailing blanks).

Types

Typed Literals (7.56)

Now supported in CDS view entities. Not supported in the ON condition of a CDS association.

{
  key id,
      abap.char'aaa   '       as char_trailing_blanks,
      abap.sstring'aaa   '  as sstring_trailing_blanks,

      abap.string'aaa   '    as string_trailing_blanks,
      'aaa'                               as untyped_literal   }
where
  numc1 = abap.numc'1' and
   datn < abap.datn'20200101'

CDS Calculated Quantity (7.56)

A new type that is the result of a calculation using amount and/or quantity fields.

Application Session Variables (7.57)

In form $session.vname

vname	Value when accessed
bs_instance_id	Instance ID of the current business service instance. The returned value has the data type SSTRING.
bs_zone_id	Zone ID of the current business service instance. The returned value has the data type SSTRING.

Input Parameters (7.57)

abap.string now supported.

ABAP Reports

RUTDDLS_MIGRATION_CANDIDATES (7.56)

Evaluates whether a migration from a CDS DDIC-based view to a CDS view entity is possible.

RUTDDLSV2MIGRATION (7.56)

Migrates CDS DDIC-based views to CDS view entities.

RUT_WHERE_USE_SQLVIEW (7.57)

Lists all repository objects that use CDS-managed DDIC views.

Annotations

Table Buffering Annotation (7.57).

Defines whether table buffering is allowed for a CDS view entity or not.

@AbapCatalog.entityBuffer.definitionAllowed: true|false

CDS entity buffer (7.57)

The actual buffering type can be defined by a separate ABAP tuning object called a CDS entity buffer with the DDL statement:

DEFINE VIEW ENTITY BUFFER ON cds_view_entity
                   LAYER CORE
                       | LOCALIZATION
                       | INDUSTRY
                       | PARTNER
                       | CUSTOMER
                   TYPE SINGLE
| {GENERIC NUMBER OF KEY ELEMENTS number}
| FULL
| NONE

Table buffering can be defined differently for the layers core, localization, industry, partner and customer.

Other

DISTINCT (7.56)

Available for SELECT statements in CDS view entities. Works like ABAP SELECT.

Reusing Expressions (7.56)

Reuse expressions defined in the SELECT list in other operand positions of the same CDS view entity.

key id                                 as field1,
    concat($projection.field1, 'x')    as field_reuse,

WHERE clause (7.56)

Now supports arithmetic expressions and case expressions as operands.

define view entity DEMO_SALES_ORDER_WHERE
  as select from
    demo_sales_order
    association to demo_sales_bupa as _partner
      on $projection.id = _partner.id
    {
      key so_key,
          id,
          company_code,
          _partner.family_name
    }
    where
          _partner.family_name like    'S%'
      and length( _partner.family_name ) = abap.int1'4'
      and created_on between abap.dats'20200101' and abap.dats'20200401'
      and cast( _partner.birth_name as DEMO_BT_BIRTH_NAME
                preserving type )  =       abap.char'Meier'

HAVING clause (7.56)

Now supports arithmetic expressions and case expressions as operands.

define view entity DEMO_CDS_VIEW_ENTITY_HAVING
  as select from sflight
  {
    concat_with_space(carrid, connid, 1) as ID,
    count(*)                             as col_count,
    seatsmax
  }
  group by
    carrid,
    connid,
    seatsmax
  having
    seatsmax > abap.int2'500'

Searched Case Expression (7.56)

Now supports arithmetic expressions and case expressions as operands.

define view entity demo_cds_searched_case_ve
  as select from
    spfli
    {
      key carrid,
      key connid,
          distance,
          distid,
          case
            when distance >= 2000 then 'long-haul flight'
            when distance >= 1000 and
                 distance <  2000 then 'medium-haul flight'
            when distance <  1000 then 'short-haul flight'
                                  else 'error'
          end as flight_type
    }
    where
      distid = 'MI'

2. CDS Abstract Entity (7.53)

Syntax

[@entity_annot1]
[@entity_annot2]
...
[DEFINE] [ROOT] ABSTRACT ENTITY abstract_entity
[parameter_list]
element_list[;]

Description

Works like a structure definition but nothing is created in DDIC and has annotations that can be evaluated with class CL_DD_DDL_ANNOTATION_SERVICE.

EXTEND ABSTRACT ENTITY (7.56)

Allows extension of existing abstract entity

EXTEND ABSTRACT ENTITY cds_abstract_entity WITH { element_list_extension }

To-Parent Association Without ON (7.56)

The ON condition can be left out of a “to-parent” if the association target is also a CDS abstract entity.

define abstract entity DEMO_CDS_ABSTRACT_CHILD
{
  key key_field  : abap.char(1);
      data_field    : abap.int4;
      _to_parent  : association to parent DEMO_CDS_ABSTRACT_COMPOSITION  
                     on _to_parent.key_field = $projection.key_field;
           <- Last line can be omitted
}

3. CDS Custom Entity (7.54)

Syntax

[@entity_annot1]
[@entity_annot2]
...
[@ObjectModel.query.implementedBy : 'class_name']
[DEFINE] [ROOT] CUSTOM ENTITY custom_entity
[parameter_list]
element_list[;]

Description

No DDIC entries created and has annotations that can be evaluated with class CL_DD_DDL_ANNOTATION_SERVICE.

Used in RAP as basis of unmanaged queries.

EXTEND CUSTOM ENTITY (7.57)

Makes it possible to add new elements to existing CDS custom entities by using CDS custom entity extensions.

EXTEND CUSTOM ENTITY CustomEntity WITH { ElementListExtension }

4. CDS Projection Views

Syntax

[@entity_annot1]
[@entity_annot2]
...
[@proj_view_annot1]
[@proj_view_annot2]
...
DEFINE [ROOT] VIEW ENTITY projection_view
   [ PROVIDER CONTRACT provider_contract] [From 7.56]
    AS PROJECTION ON cds_entity [AS alias_name]
   [association1 association2 ...]   [From 7.55]
   [redefined_assoc1 redefined_assoc2 ...]    [From 7.56]
      { projection_list }
   [WHERE cds_cond] [From 7.58 for Transactional Interfaces ]

Description

A special CDS view entity that is based on another CDS view entity (called projected entity). CDS projection views adapt a CDS data model for service-specific use cases.

Associations (7.55)

It is possible to add new, local, read-only associations association1, association2 to a projection view. Read-only associations in projection views can only be exposed but they cannot be used in path expressions to expose elements from new associations.

REDEFINE ASSOCIATION (7.56)

For Projection views it is now possible to redefine an association. In this way, it is possible to modify an association from the underlying view.

... REDEFINE ASSOCIATION [source.]_ProjAssoc [ filter] [AS _RedefinedName] redirection ...

Provider Contracts

PROVIDER CONTRACT (7.56)

For Projection views it is now possible to have a provider contract which specifies the scenario in which a CDS projection view is used. Provider contract options available:

TRANSACTIONAL_QUERY (7.56) [Default if not provided]
TRANSACTIONAL_INTERFACE (7.57) [Use for Transactional Interfaces]
ANALYTICAL_QUERY (7.57) [Use for Transient View Entities]

CDS Transactional Query (7.56)

Uses DEFINE [ROOT] VIEW ENTITY AS PROJECTION ON with provider contract “TRANSACTIONAL_QUERY”.

Transactional queries are intended for modelling the projection layer of a RAP business object. A transactional projection view must always be part of a business object. That means it must either be a root entity itself, or it must be part of a composition tree that contains a root entity

CDS Transactional Interface (7.57)

Uses DEFINE VIEW ENTITY AS PROJECTION ON with provider contract “TRANSACTIONAL_INTERFACE”.

CDS transactional interfaces serve as stable public interface layer in a CDS data model. They are typically used in the context of the ABAP RESTful Application Programming Model to provide the basis for a RAP BO interface.

WHERE (7.58) condition allowed for Transactional Interfaces.

CDS Analytical Projection Views (7.57)

Uses DEFINE TRANSIENT VIEW ENTITY AS PROJECTION ON with provider contract “ANALYTICAL_QUERY”.

A CDS DDL that is intended for modeling analytical queries within a CDS data model. A CDS analytical projection view defines an analytical query in its element_list.

The projected entity cds_entity can be an analytical cube view(7.57) or an analytical dimension view(7.58). One base view can serve as a basis for multiple analytical projection views.

How to implement "readonly : update" for draft instances

2025-01-09T17:40:28.603000+01:00

Introduction

Via the customer influence channel the requirement was raised to "allow to modify a field for a draft entity that is not already created in persistency table, the record only exists in draft table." when the field has been configured as readonly : update in the behavior definition.

Since this does not work out of the box, I will show how such a behavior, a field which is read-only after the first draft has been saved can be achieved in RAP using the SAP standard.

Problem description

When a field is being defined as readonly for update

  field ( readonly : update ) AgencyId;

and if this application is draft-enabled it turns out, that the field cannot be edited after having provided an intial value in the first dialogue of your application.

Solution ( implementation )

You can test this code with sample RAP business object that is being created using the following tutorial:

Build an SAP Fiori elements App Using the ABAP RESTful Application Programming Model (RAP) – Beginner [RAP100] | SAP Tutorials

The desired behavior can be achieved by using dynamic feature control. Instead of using the statement readonly : update you can use the following syntax in your behavior defintion.

 field ( features : instance ) AgencyId;

And in your behavior implementation in the get_instance_features() method you have to implement code that checks if an active instance of the travel entity is available.

If yes, the field will be made readonly. If not, and this is only the case when the object is being created as a draft but has not been persisted yet, the field will still be editable.

  METHOD get_instance_features.

    DATA result_line LIKE LINE OF result.

    " read relevant travel instance data
    READ ENTITIES OF zrap100_r_traveltp_rou IN LOCAL MODE
      ENTITY Travel
        FIELDS ( AgencyId )
        WITH CORRESPONDING #( keys )
      RESULT DATA(travels)
      FAILED failed.

    LOOP AT travels INTO DATA(travel).

      SELECT SINGLE * FROM zrap100_r_traveltp_rou
                      WHERE TravelId = -TravelId
                      INTO (travel_cds_line).

      result_line-%tky = travel-%tky.

      IF travel_cds_line IS NOT INITIAL.
        result_line-%features-%field-AgencyId =  if_abap_behv=>fc-f-read_only .
      ELSE.
        result_line-%features-%field-AgencyId = if_abap_behv=>fc-f-unrestricted.
      ENDIF.

      APPEND result_line TO result.

    ENDLOOP.
  ENDMETHOD.

Result

The app now behaves as follows:

We create a new travel instance.
1. We enter a value for the field AgencyId
2. and press the "Back" button

We can now see the newly created instance in our drafts
1. We select the editing status "Own Draft"
2. We select the newly created entity

When we now edit the entity again we see that the field AgencyId can still be edited
1. We press Create to persist the data.

The newly created item shows up and we press Edit again

Finally we can see that the field AgencyId has become readonly because an active instance exists.

New SAP Discovery Center Mission: Mastering SAP S/4HANA Extension with SAP Build

2025-01-10T12:27:25.847000+01:00

From the very beginning, SAP Build has been introduced as a unified low-code platform, enabling developers of all skill levels to create, extend, and automate business applications with drag-and-drop simplicity. Later, its capabilities were expanded with the integration of Java and JavaScript development, enhanced by AI features. And now the latest enhancements of SAP Build include ABAP development capabilities, advanced generative AI features, and deeper integration with SAP S/4HANA and other business applications.

SAP Build simplifies extension development and accelerates ERP modernization by seamlessly connecting all SAP development tools — ABAP, Java, JavaScript, and low-code — to enable effortless collaboration across diverse skill sets.

Start the new mission Mastering SAP S/4HANA Extension with SAP Build to try out the power of the Fusion Development experience provided by SAP Build.

Who is the mission made for?

No matter if you are a professional developer or a citizen developer with small development experience, this mission will guide you to the process of developing your extension application within a few hours.

What is it about?

The tutorial scenario is based on the following story:

Suzan, a medical technician at SBA Medical Clinic, noticed a small issue with one of the medical devices during her routine equipment checks. To address it quickly, she used the Service Hub Client mobile app to report the problem directly from her smartphone. The app, powered by SAP's Cloud Application Programming Model (CAP), immediately logged the incident in a central system, ensuring all service details were captured in one place.

Alex, the service manager at Health Tech Devices, received the report through the Service Hub Admin interface. He quickly reviewed the issue, prioritized it, and assigned a technician to fix the problem. Using the ABAP RESTful Application Programming model (RAP) power in background, Alex is able to assign the nearest processor of the issue, seeing all available technicians on the map within a selected range.

What will I do?

The final solution consists of several services and applications driven by SAP BTP.

You will start development by creating and deploying a CAP application using SAP Build Code. This application will be the heart of the project, processing data for equipment maintenance issues. All the steps will be done using the power of artificial intelligence provided by Joule. You will design a data model, expose it with the services, implement some custom logic and deploy to the Cloud Foundry environment, including SAP HANA artifacts.

You will then create another background service using SAP BTP ABAP environment. This will provide the data for the available incident processors. The data includes some processor information and geo-location. The main data of a processor is assumed to come from an SAP S/4HANA Cloud system (Business Partner data). For simplicity, this data is uploaded only once. In real production scenarios, there should be a more comprehensive integration. To reproduce this scenario, you don't need an access to a real SAP S/4HANA Cloud system as you will use the SAP Business Accelerator Hub Sandbox. In addition, you will create a service using the ABAP RESTful Application Programming model to search for the processors within a given distance range using the power of the SAP HANA database geo-engine.

To access the data from your front-end applications, you will create SAP BTP destinations.

When all background services are available you will use SAP Build Apps to create 2 cross-platform applications. You will use all the power of SAP Build Apps hidden behind the drag-and-drop simplicity, including advanced components, complex (but still intuitive) formulas, REST-based integration for non-standard data requests, and so on.

How can I start?

Try out the mission in SAP Discovery Center for free. The content of the mission is tested on a regular basis and will be kept up to date by integrating the latest services and features.

Even though this mission involves numerous services and applications, you can complete all the steps from start to finish using the SAP BTP Trial Account.

You are interested in more end-to-end missions? Pick up one of them from SAP Discovery Center.

We are excited to hear your feedback about this mission. Please feel free share your thoughts in the comment section below or reach out to us via Discovery Center support tool.

REUSE_ALV_GRID_DISPLAY - Dynamic Total in Editable ALV

2025-01-10T13:49:32.183000+01:00

In SAP ABAP, handling editable ALV (ABAP List Viewer) grids with dynamic events such as data changes and automatic summations can be tricky, but it provides a very effective way to interact with and manipulate data. The program we are reviewing here aims to achieve just that—enable editable fields in the ALV grid, track changes in those fields, and update the summation of those changes at runtime.

The main objective of the blog is to create an editable ALV grid where the user can modify the weight (BRGEW) of materials (MATNR). When any change occurs, the summation of the BRGEW field is automatically recalculated and displayed.

The ALV grid provides a user-friendly interface for displaying the data, and we utilize event handling (specifically the DATA_CHANGED event) to capture and process changes made by the user. Additionally, since the Enter key does not trigger a default action in the ALV grid, the report uses the DATA_CHANGED event to monitor any updates and recalculate the summation.

Key Concepts:

Editable ALV: The ALV grid is made editable for the field BRGEW.
Event Handling: The DATA_CHANGED event is used to detect when data in the grid changes, which triggers the summation update.
Summation: Whenever the user edits the BRGEW field, the program recalculates the total value of the BRGEW column and displays the updated sum.

Code Snippet:

REPORT ztest7.
TYPE-POOLS:slis.

DATA: gt_mara     TYPE TABLE OF ztest_s,
      gt_fieldcat TYPE slis_t_fieldcat_alv,
      gt_events   TYPE slis_t_event,
      go_grid     TYPE REF TO cl_gui_alv_grid,
      gs_stable   TYPE lvc_s_stbl,
      gr_data     TYPE REF TO data.

FIELD-SYMBOLS: <gtr_sum_tab> TYPE table.

START-OF-SELECTION.

  SELECT matnr,
         brgew
    FROM mara
    INTO TABLE _mara UP TO 10 ROWS.
  IF sy-subrc EQ 0.
    CALL FUNCTION 'REUSE_ALV_FIELDCATALOG_MERGE'
      EXPORTING
        i_program_name         = sy-repid
        i_structure_name       = 'ZTEST_S'
      CHANGING
        ct_fieldcat            = gt_fieldcat
      EXCEPTIONS
        inconsistent_interface = 1
        program_error          = 2
        OTHERS                 = 3.
    IF sy-subrc = 0.
      READ TABLE gt_fieldcat ASSIGNING FIELD-SYMBOL(<gs_fcat>) WITH KEY fieldname = 'BRGEW'.
      IF sy-subrc EQ 0.
        <gs_fcat>-edit = 'X'.
        <gs_fcat>-do_sum = 'X'.
      ENDIF.

      APPEND VALUE #( name = 'DATA_CHANGED' form = 'GET_DATA_CHANGED' ) TO gt_events.

      CALL FUNCTION 'REUSE_ALV_GRID_DISPLAY'
        EXPORTING
          i_callback_program       = sy-repid
          it_fieldcat              = gt_fieldcat
          it_events                = gt_events
          i_callback_pf_status_set = 'SET_PF_STATUS'
        TABLES
          t_outtab                 = gt_mara.
    ENDIF.
  ENDIF.


FORM set_pf_status USING itr_extab TYPE slis_t_extab.

* Get the ALV Object reference
  CALL FUNCTION 'GET_GLOBALS_FROM_SLVC_FULLSCR'
    IMPORTING
      e_grid = go_grid.
  IF go_grid IS BOUND.
    CALL METHOD go_grid->register_edit_event
      EXPORTING
        i_event_id = cl_gui_alv_grid=>mc_evt_modified.

    CALL METHOD go_grid->register_edit_event
      EXPORTING
        i_event_id = cl_gui_alv_grid=>mc_evt_enter.
  ENDIF.

  " PF Status Code
  CASE sy-ucomm.
*	WHEN
    WHEN OTHERS.
  ENDCASE.
ENDFORM.

FORM get_data_changed USING io_data_changed TYPE REF TO cl_alv_changed_data_protocol.

  IF go_grid IS BOUND.

    LOOP AT io_data_changed->mt_mod_cells ASSIGNING FIELD-SYMBOL(<gs_changed>) WHERE fieldname = 'BRGEW'.
      READ TABLE gt_mara ASSIGNING FIELD-SYMBOL(<gs_tab>) INDEX <gs_changed>-row_id.
      IF sy-subrc EQ 0.
        <gs_tab>-brgew = <gs_changed>-value.
      ENDIF.
    ENDLOOP.

    go_grid->get_subtotals(
      IMPORTING
        ep_collect00 = gr_data   " Overall Total
    ).

    ASSIGN gr_data->* TO <gtr_sum_tab>.
    READ TABLE <gtr_sum_tab> ASSIGNING FIELD-SYMBOL(<l_sum>) INDEX 1.
    IF sy-subrc EQ 0.
      ASSIGN COMPONENT 'BRGEW' OF STRUCTURE <l_sum> TO FIELD-SYMBOL(<lg_val>).
      IF <lg_val> IS ASSIGNED.
        <lg_val> = REDUCE #( INIT lv_i TYPE ntgew_15 FOR <ls_t> IN gt_mara NEXT lv_i = lv_i + <ls_t>-brgew ).
      ENDIF.
    ENDIF.

    gs_stable-col = 'X'.
    gs_stable-row = 'X'.

    go_grid->refresh_table_display(
      EXPORTING
        is_stable      = gs_stable      " With Stable Rows/Columns
        i_soft_refresh = 'X'            " Without Sort, Filter, etc.
      EXCEPTIONS
        finished       = 1              " Display was Ended (by Export)
        OTHERS         = 2
    ).
    IF sy-subrc <> 0.
    ENDIF.

  ENDIF.

ENDFORM.                    "get_data_changed

Event Handler Registration

APPEND VALUE #( name = 'DATA_CHANGED' form = 'GET_DATA_CHANGED' ) TO gt_events.

The DATA_CHANGED event is added to the event table (gt_events). This event will trigger the GET_DATA_CHANGED form when any modification happens to the grid.

Make the BRGEW Field Editable and Enable Summation

READ TABLE gt_fieldcat ASSIGNING FIELD-SYMBOL(<gs_fcat>) WITH KEY fieldname = 'BRGEW'.
IF sy-subrc EQ 0.
  <gs_fcat>-edit = 'X'.
  <gs_fcat>-do_sum = 'X'.
ENDIF.

In this section, we search for the BRGEW field in the field catalog (gt_fieldcat). If the field is found, it is set to be editable (edit = 'X') and summable (do_sum = 'X').

PF Status

FORM set_pf_status USING itr_extab TYPE slis_t_extab.
  " Get the ALV Object reference
  CALL FUNCTION 'GET_GLOBALS_FROM_SLVC_FULLSCR'
    IMPORTING
      e_grid = go_grid.
  IF go_grid IS BOUND.
    CALL METHOD go_grid->register_edit_event
      EXPORTING
        i_event_id = cl_gui_alv_grid=>mc_evt_modified.
    CALL METHOD go_grid->register_edit_event
      EXPORTING
        i_event_id = cl_gui_alv_grid=>mc_evt_enter.
  ENDIF.
  " PF Status Code
  CASE sy-ucomm.
    WHEN OTHERS.
  ENDCASE.
ENDFORM.

Intentionally, the FM GET_GLOBALS_FROM_SLVC_FULLSCR is initialized, and events are registered in the PF status so that the ENTER key press event should be detected. This can also be added in the TOP-OF-PAGE event. The ABAP code retrieves an ALV grid object (go_grid) using the function GET_GLOBALS_FROM_SLVC_FULLSCR and checks if it is properly initialized with the IS BOUND check. If the grid object is bound, it registers two edit events for the grid: one for when the user modifies data (mc_evt_modified), and another for when the user presses the Enter key (mc_evt_enter). These events are linked to the grid to allow further processing or actions in response to user interactions with the grid, such as triggering updates or executing custom logic.

Data Changed Handler (Recalculate Sum)

FORM get_data_changed USING io_data_changed TYPE REF TO cl_alv_changed_data_protocol.
  IF go_grid IS BOUND.
    LOOP AT io_data_changed->mt_mod_cells ASSIGNING FIELD-SYMBOL(<gs_changed>) WHERE fieldname = 'BRGEW'.
      READ TABLE gt_mara ASSIGNING FIELD-SYMBOL(<gs_tab>) INDEX <gs_changed>-row_id.
      IF sy-subrc EQ 0.
        <gs_tab>-brgew = <gs_changed>-value.
      ENDIF.
    ENDLOOP.
    go_grid->get_subtotals(
      IMPORTING
        ep_collect00 = gr_data   " Overall Total
    ).
    ASSIGN gr_data->* TO <gtr_sum_tab>.
    READ TABLE <gtr_sum_tab> ASSIGNING FIELD-SYMBOL(<l_sum>) INDEX 1.
    IF sy-subrc EQ 0.
      ASSIGN COMPONENT 'BRGEW' OF STRUCTURE <l_sum> TO FIELD-SYMBOL(<lg_val>).
      IF <lg_val> IS ASSIGNED.
        <lg_val> = REDUCE #( INIT lv_i TYPE ntgew_15 FOR <ls_t> IN gt_mara NEXT lv_i = lv_i + <ls_t>-brgew ).
      ENDIF.
    ENDIF.
    gs_stable-col = 'X'.
    gs_stable-row = 'X'.
    go_grid->refresh_table_display(
      EXPORTING
        is_stable      = gs_stable      " With Stable Rows/Columns
        i_soft_refresh = 'X'            " Without Sort, Filter, etc.
      EXCEPTIONS
        finished       = 1              " Display was Ended (by Export)
        OTHERS         = 2
    ).
    IF sy-subrc <> 0.
    ENDIF.
  ENDIF.
ENDFORM.

In the get_data_changed form, the system loops through the modified cells, retrieves the updated value, and updates the corresponding entry in the internal table gt_mara. Then, it calculates the sum of the BRGEW column and refreshes the ALV grid to display the updated total.

In conclusion, this blog demonstrates how to build an interactive and editable ALV grid in SAP ABAP that responds to user modifications in real-time. By leveraging the DATA_CHANGED event, we are able to efficiently track and process changes to the data, recalculate sums dynamically, and display the updated results without requiring the user to press any additional buttons. This approach provides a seamless and intuitive user experience while utilizing SAP's built-in functionality to manage the ALV grid and event handling.

Thanks for Reading!

I hope this blog post provided useful insights into creating dynamic, editable ALV grids in SAP. Feel free to adapt and customize the provided code to suit your specific needs.

Regards,
Abhijeet Tikar

Disenchantment: GPT for generating ABAP code documentation

2025-01-11T18:24:29.595000+01:00

I just asked a publicly GPT trained model at my company, to generate the documentation of an old and huge ABAP program, to see if ChatGPT can save me some time to understand what the program does.

The prompt is limited to one or two thousand characters, so I can only ask for one portion of a subroutine at a time. The generated text is just good for explaining the meaning of each individual ABAP statement. It cannot save time.

Below are two questions and answers for your information.

Did you have a better experience with GenAI for generating a good ABAP documentation?

Which engine do you use? (public, SAP Joule, privately trained model, etc.)

Thank you.

Sandra

First prompt:

Describe the detailed steps of the subroutine SAVE_COMMENT. Here is its code: FORM save_comment USING p_vl_max_fake p_ok_boolean. CLEAR sg_zfake_user. MOVE sy-datum TO sg_zfake_user-date_2. IF gw_mode = 'CREER'. MOVE sy-datum TO sg_zfake_user-date_1. MOVE 'E' TO sg_zfake_user-statut. ELSE. DELETE FROM zfake_user WHERE nfake = gi_nfake AND typefake = '2'. IF sy-subrc <> 0. ENDIF. MOVE g_date_1 TO sg_zfake_user-date_1. MOVE g_statut TO sg_zfake_user-statut. ENDIF. MOVE gi_nfake TO sg_zfake_user-nfake. MOVE '2' TO sg_zfake_user-typefake. MOVE 0 TO sg_zfake_user-notypefake. PERFORM affichage_commentaire USING 'GET' tg_fake_commentaire_user_m tg_fake_commentaire_admin_m. LOOP AT tg_fake_commentaire_user_m INTO sg_fake_commentaire. CONCATENATE sg_zfake_user-rubrique1 sg_fake_commentaire INTO sg_zfake_user-rubrique1 SEPARATED BY space. ENDLOOP. CONDENSE sg_zfake_user-rubrique1. MOVE sg_zfake_user-rubrique1 TO g_rubrique1. LOOP AT tg_fake_commentaire_admin_m INTO sg_fake_commentaire. CONCATENATE sg_zfake_user-rubrique2 sg_fake_commentaire INTO sg_zfake_user-rubrique2 SEPARATED BY space. ENDLOOP. CONDENSE sg_zfake_user-rubrique2. MOVE sg_zfake_user-rubrique2 TO g_rubrique2. MOVE p_encopiede TO sg_zfake_user-rubrique3. IF p_encopiede IS NOT INITIAL. CLEAR : b_mdp_ecc, b_sup_ecc , b_sup_decisionnel, sg_zfake_user-rubrique4, sg_zfake_user-rubrique6, sg_zfake_user-rubrique7. ELSE. IF b_mdp_ecc = 'X'. MOVE 'X' TO sg_zfake_user-rubrique4. ENDIF. IF b_mdp_infocentre = 'X'. MOVE 'X' TO sg_zfake_user-rubrique5. ENDIF. IF b_sup_ecc = 'X'. MOVE 'X' TO sg_zfake_user-rubrique6. ENDIF. IF b_sup_decisionnel = 'X'. MOVE 'X' TO sg_zfake_user-rubrique7. ENDIF. ENDIF. INSERT zfake_user FROM sg_zfake_user. IF sy-subrc <> 0. UPDATE zfake_user FROM sg_zfake_user. ENDIF. IF sy-subrc <> 0. MESSAGE 'Cannot save the comments' TYPE 'S' p_ok_boolean = 'X'. EXIT. ENDIF. ENDFORM.

The answer:

There’s a problem processing your request. Please try again later or let me know if I can help.

I shortened the prompt:

The answer:

Using publicly trained GPT model...

Sure, let's break down the subroutine `SAVE_COMMENT` step by step:

Subroutine Definition
FORM save_comment USING p_vl_max_fake p_ok_boolean.
The subroutine SAVE_COMMENT is defined with two parameters: p_vl_max_fake and p_ok_boolean.

Step 1: Clear the Work Area
CLEAR sg_zfake_user.
The work area sg_zfake_user is cleared to ensure it starts with no data.

Step 2: Set the Current Date
MOVE sy-datum TO sg_zfake_user-date_2.
The current system date (sy-datum) is moved to the field date_2 of the work area sg_zfake_user.

Step 3: Check the Mode
IF gw_mode = 'CREER'.
The subroutine checks if the mode (gw_mode) is 'CREER' (which likely means 'create').

Step 3.1: If Mode is 'CREER'
MOVE sy-datum TO sg_zfake_user-date_1.
MOVE 'E' TO sg_zfake_user-statut.
The current system date (sy-datum) is moved to the field date_1 of the work area sg_zfake_user.
The status field statut of the work area sg_zfake_user is set to 'E'.

Step 3.2: If Mode is Not 'CREER'
ELSE.
DELETE FROM zfake_user WHERE nfake = gi_nfake AND typefake = '2'.
IF sy-subrc <> 0.
ENDIF.
MOVE g_date_1 TO sg_zfake_user-date_1.
MOVE g_statut TO sg_zfake_user-statut.
The subroutine deletes entries from the database table zfake_user where nfake equals gi_nfake and typefake equals '2'.
If the deletion is not successful (sy-subrc is not zero), it does nothing (empty ENDIF).
The value of g_date_1 is moved to the field date_1 of the work area sg_zfake_user.
The value of g_statut is moved to the field statut of the work area sg_zfake_user.

Step 4: Set Additional Fields
MOVE gi_nfake TO sg_zfake_user-nfake.
MOVE '2' TO sg_zfake_user-typefake.
MOVE 0 TO sg_zfake_user-notypefake.
The value of gi_nfake is moved to the field nfake of the work area sg_zfake_user.
The value '2' is moved to the field typefake of the work area sg_zfake_user.
The value 0 is moved to the field notypefake of the work area sg_zfake_user.

Step 5: Perform Another Subroutine
PERFORM affichage_commentaire USING 'GET' tg_fake_commentaire_user_m tg_fake_commentaire_admin_m.
The subroutine affichage_commentaire is called with the parameters 'GET', tg_fake_commentaire_user_m, and tg_fake_commentaire_admin_m.

Step 6: Loop Through Internal Table
LOOP AT tg_fake_commentaire_user_m INTO sg_fake_commentaire.
CONCATENATE sg_zfake_user-rubrique1 sg_fake_commentaire INTO sg_zfake_user-rubrique1 SEPARATED BY space.
ENDLOOP.
The subroutine loops through the internal table tg_fake_commentaire_user_m and reads each entry into the work area sg_fake_commentaire.
For each entry, it concatenates the value of sg_fake_commentaire to the field rubrique1 of the work area sg_zfake_user, separated by a space.

End of Subroutine
ENDFORM.
The subroutine ends.

Summary
The SAVE_COMMENT subroutine performs the following actions:

Clears the work area sg_zfake_user.
Sets the current date in date_2.
Depending on the mode (gw_mode), it either sets the creation date and status or deletes existing entries and sets the date and status from global variables.
Sets additional fields in the work area.
Calls another subroutine affichage_commentaire.
Loops through an internal table and concatenates its entries to a field in the work area.

Date to Factory Date Conversion with S/4HANA ABAP CDS view

2025-01-16T20:15:24.433000+01:00

I wish S/4HANA ABAP CDS views supported date-to-factory-date conversion using an out-of-the-box built-in function, similar to currency or unit conversion. Unfortunately, that’s not the case. But don’t worry—I’ve got you covered with a custom-built S/4HANA ABAP CDS view.

S/4HANA provides DATE_CONVERT_TO_FACTORYDATE standard function module for date-to-factory-date conversion. Base on factory, for example, CA Canada:

The function module converts date to closest next factory date (default "+" conversion option):

or closest prior factory date ("-" conversion option):

The same date-to-factory-date conversion can be achieved using custom-built ABAP CDS view

All it takes a simple custom built ABAP CDS view

Above code does a trick transforming pivoted and nested factory calendar data

into factory calendar on date level

followed by a couple of window functions to find next and previous factory date for first / last week-end or holiday date

and copy it over to other week-end / holiday dates as well fill next factory date / previous factory date for weekdays.

Source code for the CDS view can be downloaded below:

ZI_FactoryCalendar

ZCL_FACTORY_CALENDAR

CDS Access Controls 7.5x Quick Reference

2025-01-17T05:45:21.145000+01:00

Introduction

This Quick Reference is a collection of new CDS Access Control (DCL) functionality made available in ABAP 7.5x releases. This functionality is summarised in a way that will make sense to those familiar with Access Controls. Links to the SAP Help are also provided throughout to allow the reader to dive in deeper if desired. The version the functionality was released is also given to aid in determining if it is available in your system.

S/4HANA	1511	1610	1709	1809	1909	2020	2021	2022	2023
ABAP	7.50	7.51	7.52	7.53	7.54	7.55	7.56	7.57	7.58

Contents

1. Roles

2. Access Rules

A. Conditional Rule
B. Inherited Rule (OBSOLETE)
C. Projection Rule (7.58)

3. Access Conditions

A. Literal Condition
B. PFCG Condition
C. Aspect Condition
D. User Condition (7.51)
E. Inherit Condition
F. DCL Function
G. Boolean (7.53)
H. VOID (7.53)
I. IF…THEN…ELSE (7.57)

1. Roles

@MappingRole: true
[@role_annot1]
[@role_annot2]
...
[DEFINE] ROLE role_name [SWITCHABLE] { access_rules }

CDS Role (7.50)

Access Controls are expanded to include implicit evaluations of CDS roles. If a CDS entity is associated with a CDS role, an additional access condition is checked by default when the CDS entity is accessed using ABAP SQL. Only that data is read for which the current user has an authorization or that matches a literal condition.

CDS Table Functions (7.52)

CDS roles can now also be defined for CDS table functions.

DCL Restrictions for ABAP CDS Hierarchies (7.54)

ABAP CDS hierarchies can now be protected using access controls

SWITCHABLE (7.57)

With this addition, the content of the role reacts to status changes in the Switch Framework .

2. Access Rules

A. ... conditional_rule| grant_rule
     [conditional_rule| grant_rule]
      ...

B. ... inherited_rule                         [Obsolete]
     [conditional_rule| grant_rule]
     [conditional_rule| grant_rule]
      ...

C. ... projection_rule ...                  [7.58]

A. Conditional Rule

GRANT SELECT ON cds_entity
     [WITH OPTIONAL ELEMENTS ( element1 DEFAULT { TRUE | FALSE }, ...  ) ]   [7.56]
     [COMBINATION MODE OR | COMBINATION MODE AND | REDEFINITION]        [7.54]
      WHERE cds_cond;

A conditional access rule GRANT SELECT ON with the addition WHERE restricts access to a CDS entity cds_entity using access conditions cds_cond. See section Access Conditions.

WITH OPTIONAL ELEMENTS (7.56)

By declaring elements of an access control as optional you specify that these elements may be missing in inheritance targets of the access conditions using those elements.

COMBINATION MODE OR|AND (7.54)

Used to define how the access conditions of multiple access rules for the same CDS entity cds_entity are combined.

COMBINATION MODE OR is used to combine the access conditions using the logical operator or. If created, these access rules make the restrictions less strong.

COMBINATION MODE AND combines the current access rule with the logical operator and and the other access rules. This means the restrictions are made stronger.

REDEFINITION (7.54)

Used to indicate that the specified CDS access rule is the only existing access rule and any other access rules are ignored.

Full Access Rules (7.51)

A full access rule GRANT SELECT ON without the addition WHERE provides access to a CDS entity cds_entity without conditions.

B. Inherited Rule (OBSOLETE)

C. Projection Rule (7.58)

GRANT SELECT ON cds_entity_projection
AS PROJECTION ON cds_entity_base
FALLBACK ASSOCIATION fallback_association;

A new type of access rule is available for CDS projection views of type CDS transactional query.

At runtime, the access conditions of the base view are applied to the projection view if certain conditions are met. If it is not possible to apply the access conditions of the base view directly to the projection view, all access conditions are rewritten at runtime to point to the association fallback_association.

3. Access Conditions

The result of an access condition is true or false.

A. Literal Condition

... [ALL|EXISTS] {
    { element [BYPASS WHEN bypass_condition] operator [']value['] }...
  | { element [BYPASS WHEN bypass_condition] [NOT] BETWEEN [']value1['] AND [']value2['] }
  | { element [BYPASS WHEN bypass_condition] [NOT] LIKE 'value' [ESCAPE 'esc'] }
  | { element [BYPASS WHEN bypass_condition] IS [NOT] NULL }
  | { element [BYPASS WHEN bypass_condition] IS [NOT] INITIAL } } ...

Compares an element of a CDS entity with fixed values.

ALL (7.55)

With new addition ALL, access conditions can express that access shall only be granted when from a set-valued association all values satisfy the condition.

WHERE ALL toItem.State = 'A'

BYPASS WHEN (7.55)

The addition BYPASS WHEN bypass_condition can be used to specify that the element is not used for authorization filtering if it meets the specified condition.

ALL toSetVal.F BYPASS WHEN IS NULL = 'A'

Operator ?= (7.51)

Works Like the = operator, however, condition is also met if the value of the left side is the null value or a type-dependent initial value.

BETWEEN and IS NULL (7.52)

The operators BETWEEN and IS NULL are now available for literal conditions as part of an access condition.

ESCAPE (7.52)

{ element [NOT] LIKE 'value' [ESCAPE 'esc'] }

In a literal condition [NOT] LIKE, the percent sign (%) can be used as a placeholder for any string and the underscore character (_) for any single character. The addition ESCAPE can be used to define a single character escape character 'esc' in quotation marks for the placeholders. The character # is recommended as the escape character esc for the operator LIKE.

IS [NOT] INITIAL (7.55)

In a literal condition, IS [NOT] INITIAL can now be used to check whether the value of the left side matches (does not match) the initial value of the ABAP data type that matches the element.

B. PFCG Condition

...[ALL|EXISTS]
   ([element1 [BYPASS WHEN bypass_condition]
   |{ element1[, element2 ...] }
    [, element2 [BYPASS WHEN bypass_condition]
   |{ element1[, element2 ...] } ...]] )
         =|?= ASPECT pfcg_auth
                ( auth_object [IN SCENARIO scenario_name],                      [7.54]
                 [mapped_field1|{ PFCG_MAPPING = pfcg_mapping}[,
                  mapped_field2|{ PFCG_MAPPING = pfcg_mapping} ...]][,
                  auth_field1 = 'value'[,
                  auth_field2 = 'value' ...]] ) ...

ALL (7.55)

With new addition ALL, access conditions can express that access shall only be granted when from a set-valued association all values satisfy the condition.

WHERE ALL toItem.State = 'A'

BYPASS WHEN (7.55)

The addition BYPASS WHEN bypass_condition can be used to specify that the element is not used for authorization filtering if it meets the specified condition.

ALL toSetVal.F BYPASS WHEN IS NULL = 'A'

IN SCENARIO (7.54)

Used to apply the switchable authorization (transaction SACF) to an authorization object.

PFCG Mapping

... ( ... { element1[, element2 ...] } ... )
=|?= ASPECT pfcg_auth
( ... PFCG_MAPPING = pfcg_mapping ... ) ...

Assigns an element list specified in curly brackets { element1[, element2 ...] } to a PFCG mapping pfcg_mapping in the definition of a PFCG condition.

Define PFCG Mapping

[DEFINE] PFCG_MAPPING pfcg_mapping(output1[, output2 ..spec])
  BETWEEN mapping_entity AND auth_object [IN SCENARIO scenario_name]
  { input1 = auth_field1 [CONSTRAINT ID][,
    input2 = auth_field2 [CONSTRAINT ID] ... ] }

Defines a PFCG mapping pfcg_mapping as part of a CDS access policy defined using DEFINE ACCESSPOLICY. The name of the PFCG mapping must match the name of the CDS access policy.

PFCG Mapping to Element List (7.53)

This mapping assigns the CDS elements to the authorization fields of an authorization object.

CONSTRAINT ID (7.54)

Any number of optional assignments can be flagged using the addition CONSTRAINT ID.

C. Aspect Condition

... (element1 [, element2, ...] ) = ASPECT aspect
[FILTER BY ( aspect filter )] ...

An aspect condition can now be used to specify the generic aspect defined in an aspect definition in the right side introduced by ASPECT.

WITH FILTER ELEMENTS (7.56)

Denominates an arbitrary set of elements (path expressions are supported) of an aspect as filter elements. These filter elements can by referenced when using the user-defined aspect in an access condition.

DEFINE ASPECT

[aspect_annot]
[DEFINE] ASPECT aspect AS SELECT FROM aspect_entity
  WITH USER ELEMENT user_element
  [WITH FILTER ELEMENTS ( filter_element1 [AS filter_alias1], [7.56]
        filter_element2... ) ]
{
    output1 [BYPASS WHEN aspect_bypass_condition]
    [, ... ]
}

Defines a user-defined aspect aspect as part of a CDS access policy defined using DEFINE ACCESSPOLICY. The name of the user-defined aspect must be the same as the name of the CDS access policy.

DEFINE ACCESS POLICY (7.54)

[@access_policy_annot]
[DEFINE] ACCESSPOLICY access_policy {
pfcg_mapping_definition | aspect_definition
}

Defines a CDS access policy access_policy in the CDS DCL to be used as a medium for further definitions.

D. User Condition (7.51)

In a user condition, the predefined aspect user is specified on the right side introduced with ASPECT.

DEFINE ROLE ...[ALL|EXISTS] element =|<>|?= ASPECT user ...

@MappingRole: true
define role demo_cds_role_user {  
  grant select on demo_cds_auth_user
    where
      uname ?= aspect user; }

The following can now be checked instead of the user name:

The value of the alias. (7.55)
The number of the business partner assigned to the user. (7.55)

E. Inherit Condition

... { { INHERIT parent_role FOR GRANT SELECT ON cds_entity }   [7.53]
  | { INHERITING CONDITIONS FROM
       { ENTITY cds_entity [DEFAULT TRUE|FALSE] }
       | SUPER } } [7.54]
    [ replacing ] ...    [7.54]

INHERIT parent_role (7.53)

{ INHERIT parent_role FOR GRANT SELECT ON cds_entity }

Makes old access rule (GRANT SELECT ON cds_entity INHERIT parent_role) obsolete.

@MappingRole: true
define role DEMO_CDS_ROLE_INHERITED_VE {
  grant select on DEMO_CDS_AUTH_INHERITED_VE
          where
            inherit demo_cds_role_lit_pfcg_ve
        for grant select on demo_cds_authority_lit_pfcg_ve                
      or currcode = 'USD'; }

INHERITING CONDITIONS FROM SUPER (7.54)

This variant is possible only if the access rule has the addition REDEFINITION and only if the inherited CDS entity has access controls. Instead of this condition, those conditions are used that would have been applied by the access controls disabled by REDEFINITION.

REPLACING (7.56)

... REPLACING { replacement_step [, replacement_step, ...] }

Modifies inherited access conditions from source entity cds_entity before they are applied to the protected entity of their own access rule. It contains a sequence of replacement steps replacement_step which are executed in the order.

WHERE INHERITING CONDITIONS FROM ENTITY Source REPLACING {
  ELEMENT Element1OfSource WITH Element1OfTarget,
  ELEMENT Assoc1OfSource WITH Assoc1[r = 4].Assoc2OfTarget,
  ELEMENT Assoc2(p : $parameters.p1)[ q = 1].Field WITH MyShortField }

Replacing (Role Based) (7.56)

Available for role-based inheritance

F. DCL Function

... { SACF_CHECK_IN_USE( NAME => scenario_name [, OBJECT => auth_object ] ) [7.56]
          IS [NOT] INITIAL }
  | { OPTIONAL_ELEMENT_EXISTS( NAME => element ) [7.56]
        IS [NOT] INITIAL }
  | { SWITCH_RUNTIME_STATE( NAME => switch_name ) [7.58]
        IS [NOT] INITIAL }
  | { TOGGLE_RUNTIME_STATE( NAME => toggle_name ) [7.58]
        IS [NOT] INITIAL }
  | { CONTEXT_NODE_EXISTS(...)
          IS [NOT] INITIAL } ...

SACF_CHECK_IN_USE (7.56)

Enabling/Disabling of Access Conditions Based on the State of SACF. This setting can be used to enable or disable entire condition sets.

GRANT SELECT ON cds_entity
  WHERE
    SACF_CHECK_IN_USE (NAME => NEW_AUTH_SWITCH ) IS INITIAL
      AND
    ( element ) = ASPECT PFCG_AUTH( OLD_AUTH, F )
  OR
    SACF_CHECK_IN_USE( NAME => NEW_AUTH_SWITCH ) IS NOT INITIAL
      AND
    ( element ) = ASPECT PFCG_AUTH( NEW_AUTH, F );

OPTIONAL_ELEMENT_EXISTS (7.56)

With this DCL function, existence of the given CDS element in the protected entity can be queried at runtime. Based on the outcome of the check, larger condition blocks in the access control can then be enabled or disabled.

GRANT SELECT ON cds_entity
   WITH OPTIONAL ELEMENTS (itemState DEFAULT FALSE )
     WHERE
       OPTIONAL_ELEMENT_EXISTS( NAME => itemState ) IS INITIAL
         AND
          toItem.state = 'A'
     OR
       OPTIONAL_ELEMENT_EXISTS( NAME => itemState ) IS NOT INITIAL
         AND
          itemState = 'A';

DCL function SWITCH_RUNTIME_STATE (7.58)

{ SWITCH_RUNTIME_STATE( NAME => switch_name )
IS [NOT] INITIAL }

Retrieves the runtime state of a switch in the Switch Framework (SFW). If state is “on” then IS NOT INITIAL returns TRUE.

Can only be used for switches not of type Feature Toggle.

DCL function TOGGLE_RUNTIME_STATE (7.58)

{ TOGGLE_RUNTIME_STATE( NAME => toggle_name )
IS [NOT] INITIAL }

Behaves like SWITCH_RUNTIME_STATE at runtime. Can only be used for switches of type Feature Toggle.

CONTEXT_NODE_EXISTS

Reserved for use by SAP.

G. Boolean (7.53)

New Boolean predicates TRUE and FALSE can now be used as part of an access condition.

H. VOID (7.53)

Defines that the access condition in question is ignored.

I. IF…THEN…ELSE (7.57)

Can now be used as part of an access condition.

GRANT SELECT ON cds_entity
  WHERE
    IF
      (
        ( $PARAMETERS.P1 = 'NEW' OR $PARAMETERS.P1 = 'MODERN' )
          AND
        ( ) = ASPECT PFCG_AUTH( S_DEMO )
      )
    THEN
      {
        A_NEW = 1 AND ( B_NEW ) = ASPECT PFCG_AUTH( S_DEMO, F1 )
      }
    ELSE
      {
        A_OLD = 1 AND ( B_OLD ) = ASPECT PFCG_AUTH( S_OLD, F1 )
      };

Creating SPRO Node for Flight View Clusters in SAP

2025-01-17T15:28:34.468000+01:00

This blog post provides a beginner-friendly introduction to the concept of creating a custom SPRO node and assigning a custom view cluster to it.

Introduction

In SAP, SPRO nodes provide an organized way to access and maintain configuration tasks within SAP systems. This blog demonstrates how to create a custom SPRO node for a view cluster based on flight-related data.

Scenario Overview

Imagine you are tasked with managing flight-related configuration data stored in SAP tables such as SFLIGHT (flight schedule), SCARR (airline details), and SPFLI (flight connection). You aim to create a view cluster displaying and maintaining this data and link it to a custom SPRO node for seamless navigation.

T-code to create SPRO Node: - SIMGH.

T-code to create View Cluster: - SE54.

Step-by-Step Implementation

1. Create the View Cluster: -

Step1. Go to T-Code SE11 and create a maintenance view. Provide the name and click on the create button.

Step2. Select the Maintenance view radio button and click on the Copy button.

Step3. Provide the description and in the Table/Join condition tab provide ‘SCARR’ as table name and click on View Fields.

Step4. All the key fields are automatically added to the view. To add more fields, click on the button Table fields.

Step5. Select some fields and click on the Copy button to add.

Step6. All the selected fields of the table are added to the view. now activate the view.

Step7. Creating the Table maintenance generator. Navigate along the highlighted path.

Step8. Provide the function group name, screen number and click on the create button to complete the TMG and then go back.

Step9. Now click on the Contents button.

Step10. It shows all the records.

Step11. Follow the above shown steps to create another maintenance view ‘ZMUK_SPFLI’.

Step12. Table Fields.

Step13. Create TMG (Table maintenance generator).

Step14. Follow the above shown steps to create another maintenance view ‘ZMUK_SFLIGHT’.

Step15. Table Fields.

Step16. Create TMG (Table maintenance generator).

2. Steps to Create View Cluster: -

Step1. Go to SE54 t-code.

Step2. Click on the Edit View Cluster Button.

Step3. Provide the View Cluster Name and click on the Create button.

Step4. Under the Header Entry, provide short text and double click on Object Structure.

Step5. Under Object Structure Click on New Entries Button.

Step6. Now provide the three above created maintenance view in hierarchical manner. Provide a short text for all. Set the position. Select the view ‘ZMUK_SCARR’ as the start.

Step7. Now select the first line and click on the Field-dependence button.

Step8. Now select the second line and click on the Field-dependence button.

Step9. Now select the third line and click on the Field-dependence button.

Step10. In the Header Entry section, click on the Activate button.

Step11. Go back and Click on the TEST button to test the View Cluster.

Step12. Now the records from ‘ZMUK_SCARR’ are displayed.

3. Steps to Create SPRO Node and assign the above created view cluster: -

Step1. Let’s decide the node under which we can add this table as a sub-node. Go to T-code- SPRO.

Step2. Click on SAP Reference IMG.

Step3. We figured out that we will add this customizing view cluster under the Structure (Node😞 ‘Product Compliance’.

Step4. Go to T-code: SIMGH.

Step5. Click on the F4 button against IMG Structure.

Step6. Grom the search criteria. provide ‘Product compliance’ and click on Execute button.

Step7. Select our decided structure “Product Compliance”.

Step8. Now click on the Edit button.

Step9. Now click on the Continue button.

Step10. Select the Structure ‘Product Compliance’ and click on the highlighted button (Insert structure node as sub nodes).

Step11. Provide the Node text and click on continue.

Step12. The node has been added to the structure.

Step13. Select the Sub-node and click on Activity.

Step14. Provide the ID ‘ZVCL_SPRO_MAPPING’, Name ‘SPRO view Cluster Assignment’.

Under the ‘Document’ tab, provide the document name ‘ZVCL_SPRO_MAPPING _DOC’ and click on Create button.

Scroll a bit to the right to find the create button.

Step15. Click on Allow.

Step16. Maintain some help document for the user for F1 purpose and activate it. Go Back.

When Clicked on Activate button, It will ask for package and TR, provide it and save it. And then Go back.

Step17. Now click on Maint.Objects tab as highlighted.

Step18. Provide the Maintenance Object: ID ‘ZVCL_SPRO_MAINTAIN’ and Name ‘Maintaining View Cluster Integration’.

Under the assigned Object section, provide View Cluster name ‘ZVC_FLIGHT_DEMO’ as Customizing Object, Select Type As ‘C’, and Transaction as SM34. Save it and Go Back.

Step19. The Node appears under the structure “Product Compliance” as follows. Click on the highlighted part in red color to test it.

Step20. Provide the input as AA (Airline number) and click on Continue.

Step21. Provide the connection number and click on Continue.

Step22. Click on the new entries tab.

Step23. Provide some entry and click on Save.

Step24. Go back and click on Save.

Step25. To check if Node is created successfully, go to SPRO transaction and Click on SAP reference IMG.

Step26. Expand the ‘Product Compliance’ Node and the created object appears here. Execute it to maintain the data.

File Handling In RAP ( Unmanaged )

2025-01-17T15:28:55.820000+01:00

File uploads let you add file handling functionality to your applications inside the framework of SAP's Rapid Application Programming (RAP) methodology. This gives customers the ability to upload a variety of file formats, including photos, Excel spreadsheets, PDFs, and more.

SAP's Rapid Application Programming (RAP) architecture allows you to integrate file handling functionality into your applications through file uploads. Users can now upload a variety of file kinds, including PDFs, Excel spreadsheets, photos, and more.

OData streams are now supported by the RAP framework thanks to the most recent release of SAP BTP ABAP 2208. You may now make your RAP application capable of handling and maintaining Large Objects (LOBs).This feature enables media handling by giving end users the ability to upload external files in a variety of file formats, including PDF, XLSX, binary, and others.

In this Blog we will explore how to upload and handle Large Object such as PDF or Binary files without the need to extend the RAP application in BAS.

Large objects are modelled by means of the following fields:

Attachment

Mime type

Filename

The field Attachment contains the LOB itself in a RAWSTRING format and is technically bound to the field Mime type and Filename using semantics annotation.

Mime type represents the content type of the attachment uploaded and the values for the fields Mime type and Filename are derived from the field Attachment by the RAP framework based on the maintained CDS annotations. No attachment can exist without its mime type and vice versa.

For example, when a TEXT file is uploaded the Mime type field will be derived and populated with ‘APPLICATION/txt’.

Step 1 : Create the data element of raw string Datatype for the field that stores the file attachment in the Table.

Step 2 : Creating the Database table using below fields.

Step 3 : Create the Interface view on Above Database table.

@Semantics.mimeType: true => Use the above annotations to Handle the field as Mime Type by Internal Framework and to store the attached file which is usually large data.

@Semantics.largeObject : { mime Type: 'mime type', file Name: 'filename', content Disposition Preference: #ATTACHMENT } => In this annotations we have to pass the mime type field name and the field which stores the file name.

Step 4 : Create the Projection View on Interface View.

Step 5 : Create the meta data extension for the created consumption view.

Step 6 : create the behavior definition for Interface View and choose the Implementation type as Unmanaged. For Media handling it is mandatory to create the OData v4 and with Draft functionality.

Draft table for the persistent Table.

Step 7 : Create the Implementation class for the behavior definition for CRUD operation.

CLASS lhc_zr_sm_t_file_hand DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.

    METHODS get_instance_authorizations FOR INSTANCE AUTHORIZATION
      IMPORTING keys REQUEST requested_authorizations FOR zr_sm_t_file_hand RESULT result.

    METHODS create FOR MODIFY
      IMPORTING entities FOR CREATE zr_sm_t_file_hand.

    METHODS update FOR MODIFY
      IMPORTING entities FOR UPDATE zr_sm_t_file_hand.

    METHODS delete FOR MODIFY
      IMPORTING keys FOR DELETE zr_sm_t_file_hand.

    METHODS read FOR READ
      IMPORTING keys FOR READ zr_sm_t_file_hand RESULT result.

    METHODS lock FOR LOCK
      IMPORTING keys FOR LOCK zr_sm_t_file_hand.

ENDCLASS.

CLASS lhc_zr_sm_t_file_hand IMPLEMENTATION.

  METHOD get_instance_authorizations.
  ENDMETHOD.

  METHOD create.

    zcl_sm_unmanaged_crud=>get_instance(  )->create(
      EXPORTING
        entities = entities
      CHANGING
        mapped   = mapped
        failed   = failed
        reported = reported
    ).

  ENDMETHOD.

  METHOD update.

  zcl_sm_unmanaged_crud=>get_instance(  )->update(
    EXPORTING
      entities = entities
    CHANGING
      mapped   = mapped
      failed   = failed
      reported = reported
  ).

  ENDMETHOD.

  METHOD delete.

    CALL METHOD zcl_sm_unmanaged_crud=>get_instance(  )->delete(
      EXPORTING
        keys     = keys
      CHANGING
        mapped   = mapped
        failed   = failed
        reported = reported
    ).

  ENDMETHOD.

  METHOD read.

    zcl_sm_unmanaged_crud=>get_instance(  )->read(
      EXPORTING
        keys     = keys
      CHANGING
        result   = result
        failed   = failed
        reported = reported
    ).

  ENDMETHOD.

  METHOD lock.
  ENDMETHOD.

ENDCLASS.

CLASS lsc_ZR_SM_T_FILE_HAND DEFINITION INHERITING FROM cl_abap_behavior_saver.
  PROTECTED SECTION.

    METHODS finalize REDEFINITION.

    METHODS check_before_save REDEFINITION.

    METHODS save REDEFINITION.

    METHODS cleanup REDEFINITION.

    METHODS cleanup_finalize REDEFINITION.

ENDCLASS.

CLASS lsc_ZR_SM_T_FILE_HAND IMPLEMENTATION.

  METHOD finalize.
  ENDMETHOD.

  METHOD check_before_save.
  ENDMETHOD.

  METHOD save.

    zcl_sm_unmanaged_crud=>get_instance(  )->save_data(
      CHANGING
        reported = reported
    ).

  ENDMETHOD.

  METHOD cleanup.
  ENDMETHOD.

  METHOD cleanup_finalize.
  ENDMETHOD.

ENDCLASS.

Step 8 : Create the API class for the Implementation class.

CLASS zcl_sm_unmanaged_crud DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    TYPES: tt_std_create     TYPE TABLE FOR CREATE zr_sm_t_file_hand,
           tt_std_update     TYPE TABLE FOR UPDATE zr_sm_t_file_hand,
           tt_mapped_early   TYPE RESPONSE FOR MAPPED EARLY zr_sm_t_file_hand,
           tt_failed_early   TYPE RESPONSE FOR FAILED EARLY zr_sm_t_file_hand,
           tt_reported_early TYPE RESPONSE FOR REPORTED EARLY zr_sm_t_file_hand,
           tt_mapped_late    TYPE RESPONSE FOR MAPPED LATE zr_sm_t_file_hand,
           tt_reported_late  TYPE RESPONSE FOR REPORTED LATE zr_sm_t_file_hand,
           tt_keys_read      TYPE TABLE FOR READ IMPORT zr_sm_t_file_hand,
           tt_keys_delete    TYPE TABLE FOR DELETE zr_sm_t_file_hand,
           tt_read_result    TYPE TABLE FOR READ RESULT zr_sm_t_file_hand.

    CLASS-METHODS get_instance RETURNING VALUE(ret_student) TYPE REF TO zcl_sm_unmanaged_crud.

    METHODS: create IMPORTING entities TYPE tt_std_create
                    CHANGING  mapped   TYPE tt_mapped_early
                              failed   TYPE tt_failed_early
                              reported TYPE tt_reported_early,

             read IMPORTING keys     TYPE tt_keys_read
                  CHANGING  result   TYPE tt_read_result
                            failed   TYPE tt_failed_early
                            reported TYPE tt_reported_early,

             update IMPORTING entities TYPE tt_std_update
                    CHANGING  mapped   TYPE tt_mapped_early
                              failed   TYPE tt_failed_early
                              reported TYPE tt_reported_early,

             delete IMPORTING keys     TYPE tt_keys_delete
                    CHANGING  mapped   TYPE tt_mapped_early
                              failed   TYPE tt_failed_early
                              reported TYPE tt_reported_early,

             save_data CHANGING reported TYPE tt_reported_late.

  PROTECTED SECTION.
  PRIVATE SECTION.
    CLASS-DATA: go_instance TYPE REF TO zcl_sm_unmanaged_crud,
                gt_create   TYPE TABLE OF zsm_t_file_hand,
                gt_update   TYPE TABLE OF zsm_t_file_hand,
                gr_delete   TYPE RANGE OF zr_sm_t_file_hand-DocumentId,
                gs_file     TYPE zsm_t_file_hand.
ENDCLASS.



CLASS zcl_sm_unmanaged_crud IMPLEMENTATION.

  METHOD get_instance.

    ret_student = COND #( WHEN go_instance IS BOUND THEN go_instance
                          ELSE NEW #(  ) ).

  ENDMETHOD.

  METHOD create.

    gt_create = CORRESPONDING #( entities MAPPING FROM ENTITY ).

    LOOP AT entities ASSIGNING FIELD-SYMBOL(<lfs_entities>).

      IF gt_create IS NOT INITIAL.

        gt_create[ 1 ]-client = sy-mandt.
        gt_create[ 1 ]-last_changed_by = sy-uname.
        GET TIME STAMP FIELD DATA(lv_timestamp).
        gt_create[ 1 ]-last_changed_at = lv_timestamp.

        mapped-zr_sm_t_file_hand = VALUE #( ( %cid = <lfs_entities>-%cid
                                              %key = <lfs_entities>-%key
                                              %is_draft = <lfs_entities>-%is_draft ) ).
      ENDIF.


    ENDLOOP.
  ENDMETHOD.

  METHOD save_data.

    IF gt_create IS NOT INITIAL.

      INSERT zsm_t_file_hand FROM TABLE _create.
      CLEAR gt_create[].

    ELSEIF gt_update IS NOT INITIAL.

      UPDATE zsm_t_file_hand FROM TABLE _update.
      CLEAR gt_update[].

    ELSEIF gr_delete IS NOT INITIAL.

      DELETE FROM zsm_t_file_hand WHERE document_id IN _delete.
      CLEAR gr_delete[].

    ENDIF.

  ENDMETHOD.

  METHOD update.

    DATA : lt_update_x TYPE STANDARD TABLE OF zsm_ts_boolean,
           lt_update   TYPE STANDARD TABLE OF zsm_t_file_hand.

    lt_update = CORRESPONDING #( entities MAPPING FROM ENTITY ).
    lt_update_x = CORRESPONDING #( entities MAPPING FROM ENTITY USING CONTROL ).

    IF lt_update IS NOT INITIAL.
*
      SELECT * FROM zsm_t_file_hand FOR ALL ENTRIES IN _update
      WHERE document_id = _update-document_id
      INTO TABLE (lt_result_old).

    ENDIF.
    GET TIME STAMP FIELD DATA(lv_timestamp).
    gt_update = VALUE #(

                 FOR x = 1 WHILE x LE lines( lt_update )

                 LET ls_control_flag = VALUE #( lt_update_x[ x ] OPTIONAL )
                     ls_new   = VALUE #( lt_update[ x ] OPTIONAL )
                     ls_old   = VALUE #( lt_result_old[ document_id = ls_new-document_id ] OPTIONAL )

                 IN
                 (
                    client     = sy-mandt
                    document_id = COND #( WHEN ls_control_flag-document_id IS INITIAL
                                          THEN ls_old-document_id )
                    filename = COND #( WHEN ls_control_flag-filename IS NOT INITIAL
                                      THEN ls_new-filename ELSE ls_old-filename )
                   attachment = COND #( WHEN ls_control_flag-attachment IS NOT INITIAL
                                      THEN ls_new-attachment ELSE ls_old-attachment )
                   mimetype = COND #( WHEN ls_control_flag-mimetype IS NOT INITIAL
                                      THEN ls_new-mimetype ELSE ls_old-mimetype )
                   created_at = COND #( WHEN ls_control_flag-created_at IS INITIAL
                                      THEN ls_old-created_at )
                   created_by = COND #( WHEN ls_control_flag-created_by IS INITIAL
                                      THEN ls_old-created_by )
                   last_changed_at = COND #( WHEN ls_control_flag-last_changed_at IS INITIAL
                                      THEN lv_timestamp )
                   last_changed_by = COND #( WHEN ls_control_flag-last_changed_by IS INITIAL
                                      THEN sy-uname )

                  ) ).


  ENDMETHOD.

  METHOD read.

    SELECT * FROM zsm_t_file_hand FOR ALL ENTRIES IN 
    WHERE document_id = -DocumentId
    INTO TABLE (lt_result).

    result = CORRESPONDING #( lt_result MAPPING TO ENTITY ).

  ENDMETHOD.

  METHOD delete.

     DATA: lt_delete TYPE STANDARD TABLE OF zsm_t_file_hand.

           lt_delete = CORRESPONDING #( keys MAPPING FROM ENTITY ).

           gr_delete = VALUE #(

                             FOR ls_delete IN lt_delete
                             sign = 'I' option = 'EQ' ( low = ls_delete-document_id )
                              ).

  ENDMETHOD.

ENDCLASS.

Step 7 : create the behavior definition for the Projection View.

Step 8 : Create the Service definition for the consumption view.

Step 9 : Create the Service Binding for Created Service definition and Choose the Binding type as OData V4 ,activate and publish the service.

Preview the Application and click on create to upload the file.

Click on upload icon near to the attachment field, select the file, file name will be auto filled and fill the Mime type manually.

Unlock Your Future: Prove Your ABAP Cloud Readiness Today!

2025-01-20T13:34:03.019000+01:00

In the fast-evolving tech landscape, staying ahead means embracing the future. And in the world of ABAP development, that future is ABAP Cloud.

What is ABAP Cloud?

ABAP Cloud is the cutting-edge evolution in ABAP development. It's your gateway to creating cloud-ready business applications, services, and extensions that stand the test of time. Imagine harnessing the power of Core Data Services (CDS) for seamless data modelling, the ABAP RESTful Application Programming Model (RAP) for streamlined service development, and a cloud-optimized ABAP language that makes your business logic soar.

This all-encompassing programming model caters to both the SAP Business Technology Platform and SAP S/4HANA, working harmoniously across public cloud, private cloud, and on-premise environments. It's not just the next step—it's the future.

Get Certified and Stand Out

Ready to showcase your ABAP Cloud expertise? The SAP Certified Associate - Back-End Developer - ABAP Cloud certification is your ticket to proving your prowess. But how do you prepare for this transformative exam?

Explore Your Training Options

Whether you're a fan of interactive classroom experiences or prefer the flexibility of e-learning, SAP has you covered.

If you appreciate the benefits of classroom training, you can prepare for the certification with the classroom training courses S4D400 (Basic ABAP Programming), S4D401 (Intermediate ABAP Programming) and S4D430 (Data Modelling in ABAP Dictionary and ABAP Core Data Services) - as shown in the curriculum map below. Building on S4D430, the free e-learning Practicing Clean Core Extensibility for SAP S/4HANA Cloud covers the remaining content required for the exam.

In-Depth Knowledge: Even though the 5-day classroom training course S4D437 (Building Transactional Apps with the ABAP RESTful Application Programming Model) - also shown in the curriculum map - isn't included in the exam, it's a goldmine for those serious about mastering the ABAP RESTful Application Programming Model. We highly recommend it!

E-Learning Flexibility: For those who prefer learning at their own pace, there are excellent alternatives. Instead of attending the classroom training courses S4D400, S4D401 and S4D430, you can alternatively work through the free e-learning Acquiring Core ABAP Skills. It covers the entirety of the three classroom training courses, allowing you to study whenever and wherever you want.

Mix and Match Your Learning Path

Flexibility is key. Combine classroom and e-learning approaches to fit your schedule and learning style. For example, attend S4D400 in person, then switch to the e-learning Acquiring Core ABAP Skills to cover the content of S4D401 and S4D430 — it's entirely your call. The e-learning content is carefully designed to mirror classroom training, so you won't miss a beat.

Your Path, Your Future

Chart your own course to ABAP Cloud certification. Take control of your learning journey, prove your skills, and unlock unparalleled opportunities in the tech world.

Ready to embark on this exciting journey? Your future in ABAP Cloud awaits!

This article has been created by Christoph Knecht

Sending Multiple Documents Via Email

2025-01-21T19:02:43.392000+01:00

Introduction:

Sending a single attachment via email in SAP ABAP is straightforward, thanks to built-in functionality. However, sending multiple attachments is more complex, involving challenges like proper encoding, and maintaining the email structure. In this blog, we’ll explore the steps to overcome these complexities and successfully send multiple attachments in a single email. By the end, you’ll have a clear understanding of how to handle multiple files and ensure they’re correctly delivered.

Data Declarations:

DATA: lo_send_request TYPE REF TO cl_bcs. "VALUE IS INITIAL. 
 CLASS cl_bcs DEFINITION LOAD. 
 DATA: lo_document TYPE REF TO cl_document_bcs . "VALUE IS INITIAL. "document object 
 DATA : it_text TYPE bcsy_text. "Table for body 
 DATA : wa_text LIKE LINE OF it_text. "work area for message body 
 DATA: lo_sender TYPE REF TO if_sender_bcs. "VALUE IS INITIAL. "sender 
 DATA: lo_recipient TYPE REF TO if_recipient_bcs." VALUE IS INITIAL. "recipi

Data declarations are made for various objects that will be used to send emails
it_text is an internal table used for storing the body content of the email.
lo_sender and lo_recipient will store the sender and recipient details for the email.
Data related to attachments (it_mara, it_sflight) is declared to hold material data and flight data, which will later be attached to the email as files.

 

PARAMETERS p_mtart TYPE mara-mtart. "material type input 
 PARAMETERS p_CARRID TYPE Sflight-carrid. " Airline code input 
 PARAMETERS : p_email TYPE UNAME. "Email input 
 PARAMETERS: p_sub TYPE char50. "email subject

The selection screen gathers user input for:

p_mtart: Material type to filter the MARA table.
p_carrid: Airline code to filter the Sflight table.
p_email: Recipient's email address.
p_sub: Subject for the email.

DATA : it_mara TYPE TABLE OF mara, 
        wa_mara TYPE mara. 
 DATA : it_sflight TYPE TABLE OF Sflight, 
        wa_sflight TYPE Sflight.

it_mara: This is an internal table (TABLE OF mara) that will hold multiple rows of material data fetched from the MARA table.
wa_mara: This is a work area (TYPE mara) used to temporarily store a single row of data from the MARA
it_sflight: This is an internal table (TABLE OF Sflight) that will store multiple rows of flight data fetched from the Sflight table.
wa_sflight: This is a work area (TYPE Sflight) used to temporarily hold a single row of flight

DATA : lv_string             TYPE string, 
        lv_string_flight      TYPE string, 
        lv_data_string        TYPE string, 
        lv_data_string_flight TYPE string, 
        lv_xstring            TYPE xstring, 
        lv_xstring_flight     TYPE xstring.

lv_string: A string variable used to store concatenated data related to material information during the loop over it_mara.
lv_string_flight: A string variable used to store concatenated data related to flight details during the loop over it_sflight.

lv_data_string: A string variable that accumulates all concatenated material data (from lv_string). This data will be used to create the email attachment for material information.
lv_data_string_flight: A string variable that accumulates all concatenated flight data (from lv_string_flight). This data will be used to create the email attachment for flight information.
lv_xstring: This variable is used to store the material data in binary format (XSTRING). The data stored in lv_data_string will be converted into lv_xstring before it is used as an email attachment.
lv_xstring_flight: Similar to lv_xstring, this variable stores the flight data in binary format (XSTRING). The data stored in lv_data_string_flight will be converted into lv_xstring_flight for the email attachment.

DATA: lit_binary_content        TYPE solix_tab, 
       lit_binary_content_flight TYPE solix_tab, 
       l_attsubject              TYPE sood-objdes.

lit_binary_content: This is a table of type solix_tab, which will hold the binary content of the material data attachment after conversion from lv_xstring using SCMS_XSTRING_TO_BINARY.
lit_binary_content_flight: Similar to lit_binary_content, this table holds the binary content of the flight data attachment after conversion from lv_xstring_flight to binary format.
l_attsubject: This variable holds the subject or name for the email attachment. It is typically used to give a descriptive name to the file being attached to the email

Creating Email Object (lo_send_request)

lo_send_request = cl_bcs=>create_persistent( ).

This line creates a persistent email object using the class cl_bcs. The create_persistent method initializes the object that will be used to send the email.

Message Body Creation :

wa_text-line = '<HTML><BODY>'. 
   APPEND wa_text TO it_text. 
   wa_text-line = 'Dear Recepient,'. 
   APPEND wa_text TO it_text. 
   wa_text-line = '<br></br>'. 
   APPEND wa_text TO it_text. 
   wa_text-line = 'Please find the Flight Details And Material Data  as requested in the attachment.'. 
   APPEND wa_text TO it_text. 
   wa_text-line = '<br></br>'. 
   APPEND wa_text TO it_text. 
   wa_text-line = 'Thanks & Regards , Sender'. 
   APPEND wa_text TO it_text. 
   wa_text-line = '</BODY></HTML>'. 
   APPEND wa_text TO it_text. 
   CLEAR wa_text.

This section creates the body content for the email in HTML format.
The body text includes a greeting, an explanation of the attachments, and a closing message.
The content is stored in the it_text internal table, which will later be used as the email body.

Create Document for Email:

lo_document = cl_document_bcs=>create_document( 
   EXPORTING "create document 
   i_type = 'HTM' "Type of document HTM, TXT etc 
   i_text = it_text "email body internal table 
   i_subject = p_sub ). "email subject here p_sub input parameter 
 * Pass the document to send request 
   lo_send_request->set_document( lo_document ).

This block creates a document object for the email using cl_document_bcs. It specifies that the document type is HTML (i_type = 'HTM'), assigns the email body (i_text = it_text), and sets the email subject (i_subject = p_sub).

Attach Material Data (from MARA table):

SELECT * FROM mara INTO TABLE it_mara UP TO 100 ROWS 
   WHERE mtart = p_mtart. 
  
   LOOP AT it_mara INTO wa_mara. 
     CONCATENATE wa_mara-matnr wa_mara-mtart wa_mara-meins wa_mara-mbrsh wa_mara-matkl INTO lv_string SEPARATED BY 
     cl_abap_char_utilities=>horizontal_tab. 
     CONCATENATE lv_data_string lv_string INTO lv_data_string SEPARATED BY cl_abap_char_utilities=>newline. 
   ENDLOOP.

The SELECT query retrieves material data from the MARA table based on the material type (p_mtart).
It then loops through the retrieved data and concatenates relevant fields (material number, type, unit, etc.) into a string lv_string. The string is then added to lv_data_string, which will be used as the attachment content.

Convert String to XSTRING and Binary:

CALL FUNCTION 'HR_KR_STRING_TO_XSTRING' 
     EXPORTING 
       unicode_string   = lv_data_string 
 *     OUT_LEN          = 
     IMPORTING 
       xstring_stream   = lv_xstring 
     EXCEPTIONS 
       invalid_codepage = 1 
       invalid_string   = 2 
       OTHERS           = 3. 
   IF sy-subrc <> 0. 
     IF sy-subrc = 1 . 
     ELSEIF sy-subrc = 2 . 
       WRITE:/ 'invalid string ' . 
     ENDIF. 
   ENDIF.

The function HR_KR_STRING_TO_XSTRING is called to convert the string lv_data_string into an xstring (binary format).
The result is stored in lv_xstring.

CALL FUNCTION 'SCMS_XSTRING_TO_BINARY' 
     EXPORTING 
       buffer     = lv_xstring 
     TABLES 
       binary_tab = lit_binary_content.

The function SCMS_XSTRING_TO_BINARY is used to convert the xstring (lv_xstring) into binary content (lit_binary_content), which can be used as an attachment.

Add Attachment to Email:

add attachment 
   CLEAR l_attsubject . 
   CONCATENATE 'MaterialData_Excel' sy-datum INTO l_attsubject. 
 * Create Attachment 
   TRY. 
       lo_document->add_attachment( EXPORTING 
       i_attachment_type = 'XLS' 
       i_attachment_subject = l_attsubject 
       i_att_content_hex = lit_binary_content ). 
     CATCH cx_document_bcs INTO DATA(lx_document_bcs). 
   ENDTRY.

A new subject for the attachment is created (l_attsubject).
The add_attachment method is used to attach the material data (lit_binary_content) as an Excel file (i_attachment_type = 'XLS') to the email.

Set Sender for the Email:

TRY. 
       lo_sender = cl_sapuser_bcs=>create( sy-uname ). "sender is the logged in user 
 * Set sender to send request 
       lo_send_request->set_sender( 
       EXPORTING 
       i_sender = lo_sender ). 
   ENDTRY.

The cl_sapuser_bcs=>create method creates the sender object using the logged-in user (sy-uname).
The set_sender method is used to associate the sender with the email.

Attach Flight Data (from Sflight table):

SELECT * FROM sflight INTO TABLE it_sflight UP TO 100 ROWS 
   WHERE carrid = p_carrid. 

   LOOP AT it_sflight INTO wa_sflight. 
     CONCATENATE wa_sflight-carrid wa_sflight-connid wa_sflight-currency wa_sflight-fldate wa_sflight-planetype INTO lv_string_flight SEPARATED BY 
     cl_abap_char_utilities=>horizontal_tab. 
     CONCATENATE lv_data_string_flight lv_string_flight INTO lv_data_string_flight SEPARATED BY cl_abap_char_utilities=>newline. 
   ENDLOOP.

Similar to the material data section, this block retrieves flight data from the Sflight table based on the airline code (p_carrid).
The relevant flight details are concatenated into a string and stored in lv_data_string_flight.

Convert Flight Data to XSTRING and Binary:

CALL FUNCTION 'HR_KR_STRING_TO_XSTRING' 
     EXPORTING 
 *     codepage_to      = '8300' 
       unicode_string   = lv_data_string_flight 
 *     OUT_LEN          = 
     IMPORTING 
       xstring_stream   = lv_xstring_flight 
     EXCEPTIONS 
       invalid_codepage = 1 
       invalid_string   = 2 
       OTHERS           = 3. 
   IF sy-subrc <> 0. 
     IF sy-subrc = 1 . 
     ELSEIF sy-subrc = 2 . 
       WRITE:/ 'invalid string ' . 
     ENDIF. 
   ENDIF. 
 ***Xstring to binary 
   CALL FUNCTION 'SCMS_XSTRING_TO_BINARY' 
     EXPORTING 
       buffer     = lv_xstring_flight 
     TABLES 
       binary_tab = lit_binary_content_flight.

This process is identical to the material data conversion. The same functions (HR_KR_STRING_TO_XSTRING and SCMS_XSTRING_TO_BINARY) are used to convert the flight data into binary format.

Add Flight Data Attachment:

*add attachment 
   CLEAR l_attsubject . 
   CONCATENATE 'Flight_data' sy-datum INTO l_attsubject. 
 * Create Attachment 
   TRY. 
       lo_document->add_attachment( EXPORTING 
       i_attachment_type = 'XLS' 
       i_attachment_subject = l_attsubject 
       i_att_content_hex = lit_binary_content_flight ). 
     CATCH cx_document_bcs INTO DATA(lx_document_bcs_flight). 
   ENDTRY.

A new subject for the attachment is created (l_attsubject).
The add_attachment method is used to attach the material data (lit_binary_content) as an Excel file (i_attachment_type = 'XLS') to the email

 TRY. 
       lo_sender = cl_sapuser_bcs=>create( sy-uname ). "sender is the logged in user 
       lo_send_request->set_sender( 
       EXPORTING 
       i_sender = lo_sender ). 
   ENDTRY.

Here are defining the sender name , using SY-UNAME we are defining that the user who has logged in he is sender .

Set Recipient for the Email:

DATA(lo_bcs) = cl_bcs=>create_persistent( ). 
   DATA(lo_user) =  cl_sapuser_bcs=>create( i_user = 'HANAUSER15'). 
   lo_bcs->add_recipient( EXPORTING i_recipient  =   lo_user ). 
TRY. 
       lo_send_request->add_recipient( 
       EXPORTING 
       i_recipient = lo_user 
       i_express = 'X' ). 
   ENDTRY.

A recipient is added to the email using cl_sapuser_bcs. Here, the recipient is hardcoded as HANAUSER15, but it can be replaced with p_email (email parameter) for dynamic recipient selection.

Send the Email:

TRY. 
       CALL METHOD lo_send_request->set_send_immediately 
         EXPORTING 
           i_send_immediately = p_send. "here selection screen input p_send 
  
  ENDTRY. 
   TRY. 
 ** Send email 
       lo_send_request->send( 
       EXPORTING 
       i_with_error_screen = 'X' ). 
       COMMIT WORK. 
       IF sy-subrc = 0. "mail sent successfully 
         WRITE  'Mail sent successfully'. 
       ENDIF. 
   ENDTRY.

The send method is called to send the email with all attachments and content.
The COMMIT WORK ensures that the changes are committed to the database.
A success message is displayed if the email is sent successfully.

After activating and executing the code we can see the input screen

After executing

After executing this we can see the mail in T-CODE SBWP

Once we open SBWP t-code () we will get a pop up notification

In the inbox we can see the mails that we have received

When we open the Mail we can see that we have 2 attachments with the E-MAIL

The 2025 SAP Developer Survey is Live - Contribute Now

2025-01-23T03:52:59.925000+01:00

Attention SAP Developers!

The 2025 SAP Developer Insights Survey starts today and will be running through the first week in March. It will take about twelve minutes of your time to complete.

2025 marks the sixth consecutive year for this survey. If you design, develop, or test software for SAP applications, platforms, or data: we have questions for you.

Take the 2025 SAP Developer Survey now

As always, the survey data in anonymous. The information we gather is important to us. It is a key resource we use to understand who you are and what you do. These data play an important role in shaping channels, programs, and to focus new content on your needs.

We also publish the results back to you. If you are curious, have a look at the report describing last year’s survey results.

The survey period begins today, January 23rd. It will continue for six weeks, ending around March 7th. Our report on this 2025 survey will be released a few weeks after that.

Help us help the SAP Community. Your contribution is important.