German is the language of the SAP Fiori Launchpad. How can I translate it to English?

Review SAP Fiori Tutorial Part III: Three Flow Charts to get the idea of improving the standard Fiori apps. As an example, let’s say you work as a developer in the UK and are unexpectedly given a project that involves non-English speaking nations like Germany, France, Portugal, etc. You ask yourself, what’s the big deal?You could manage it because ABAP is a common language.

As a developer for Fiori, your first job is to figure out why users in the UK are seeing the Fiori Launchpad in German.

You access the client’s Citrix/VPN and notice the German log-on below.

You make a quick guess: it’s possible that German, DE-Deutsch, is the GUI Logon Pad’s default language. As a result, German appears in the Fiori Launchpad as well.

Let’s examine the SAP Logon Pad. You’re correct. Yes, DE (German) is the default language on the Logon Pad.

You continue to do this. By taking the actions listed below, you can set EN (English) as the default language.

It would request the confirmation listed below if you clicked OK. Press OK once again.

Start the Logon Pad again now.

That you finished the case in under two minutes makes you proud. Let’s take another look at the Fiori Launchpad. Since we have changed the default language in the SAP Logon Pad to EN, we anticipate that the language will also change to EN.

Whoops! It’s still in German on the Fiori Log On Pad.

The fiori launchpad and SAP Log On Pad are unrelated, we have learned. See Also: SAP Fiori Tutorial, Section I: Installation, Configuration, and System Check. you now acknowledge the gravity of the situation. After much searching, you eventually arrive at www.technicalgyanguru.com and discover this post.

The Internet Explorer (or Firefox/Chrome, etc.) default language determines the language that the Fiori Launch Pad displays by default.

The three steps listed below must be followed in order to modify Internet Explorer’s default language:

In Internet Explorer, click Tools.

2. Select the General Tab, then click Languages under Internet Options.

3. The German language would be displayed as the first choice. Simply use the arrows or the move up and down buttons to bring English—which isn’t the initial option—to the top.

Click OK, OK, to restart the Fiori Launch Pad’s internet browser.

The sorcery was successful. The Fiori Launch Pad is now available in your native tongue. Fiori, which translates to “flower” in Italian, meaning “have fun.”

Ever desired to master SAP ABAP for HANA? but were unsure of where to begin? View these tutorials on ABAP for HANA.

Thus…How Do You Feel?

We would now like to speak with you.

What are your thoughts on this matter?You will undoubtedly run into a language barrier if you ever work on an international project whose execution is taking place across continents.We previously encountered translation problems with Adobe, SAPScripts, SmartForms, and ABAP reports. The Fiori Apps are now in the spotlight.

you may be interested in this blog here:-

Good Practices for Salesforce Maintenance and Optimization

Understanding and Addressing “FOR UPDATE” Lock Issues in MySQL

Navigating SAP’s E070 Table in SAP: The Heartbeat of Transport Management

The post Part IV: SAP Fiori Tutorial. How can I modify the Fiori Launch Pad’s default language if it’s not English? first appeared on TECHNICAL GYAN GURU.

Fiori Client’s Zoom Options

How can ZOOM options be brought in?
What is the process for opening a document using a third-party application?

The built-in Fiori Client attachment plugin, is the answer.

The code snippet to accomplish the functionality is shown below.

1. Display the document

Put the code below on the unified uploader’s change event.

var oCore = sap.ui.getCore();
var oFile = oEvent.oSource.oFileUpload.files[0];
if (oFile) {
var vPath = URL.createObjectURL(oFile);
try {
if (oFile.type == "application/pdf") {
// For mime type PDF this below code invokes adobe reader
var reader = new FileReader();
reader.readAsDataURL(oFile);
reader.onload = function() {
window.open(reader.result);
};
reader.onerror = function(error) {
sap.m.MessageToast
.show("Unable to open file");
};
} else {
// For mime type JPG PNG this below code invokes gallery
window.open(vPath);
}
} catch (e) { // Error in case of any failures to be catched }

2. View the document after downloading from Getstream.

try {
window
.open(encodeURI("/sap/opu/odata/Service/AttachSet(Property1='"
+ vValue1
+ "',Property2='"
+ vValue2
+ "')/$value"));
} catch (e) { // Error in case of any failures to be catched }

Shots showing how to operate it.

Launch the Fiori Client App.

Select on browse button

Select an image that requires the user to enlarge before proceeding with any actions.

Zoom options will be accessible as soon as the file uploader’s change function is called.

Select a PDF file to open the PDF app and access the zoom features

See Also: Complete Guide for My Inbox PO Approval Application

Likewise, if you need to use Getstream to open the Adobe Reader or gallery/in-app window. Utilize the download feature. The associated app is automatically invoked based on the backend’s mime type.

I think this post will give you the guidance you need to activate and call the appropriate Zoom feature routines. Please feel free to contact me or post your questions in the comments area below if you need any additional information or if you have any more questions.

you may be interested in this Blog here:-

SAP S/4HANA Cloud Public Edition 2408: A Comprehensive Guide to Product Implementation

5 Methods for Using Your Salesforce Email Sender Reputation: An Story of Redemption

The post Display & Download PNG JPG PDF Document in SFiori Client Android with 3rd Party App for Zoom/additional options first appeared on TECHNICAL GYAN GURU.

We had to create a report using splitter containers and a ALV tree structure per a client request. Although handling the combination of these two may seem challenging, it is actually rather simple. We quickly constructed a prototype, and it was flawless.

The basic programming skeleton of the prototype described below can be improved in a number of ways, but it should not change. We discovered certain hotly debated subjects online as we developed, and I’ve tried to hone in on them and address them in this piece.

Goal

This article’s goal is to clarify the usage of the TREE MODEL (TREE_STRUCTURE) and SPLITTER CONTAINER in OOPs ABAP report generation that integrates standard events.

The second, and more significant goal, is to permanently dispel our phobia of using Splitter Containers and Tree Models.

Range

• This article addresses the following typical issues that developers run into:
• When divided into many sub-containers, the custom container can be used to fill the entire screen.
• Registering custom events using the tree model’s standard events
• Customize splitter container widths.

Overview

The report with two containers in the list screen is displayed using the code that follows. The tree model is intended to be contained in the left panel container, while the contents of the left panel document will be displayed in the right container in response to a double click. This example shows how to design a tree structure using sales orders and sales contracts as the antecedent documents. Certain selection screen criteria can be applied to these sales orders in order to choose them. When the leaf node is clicked, the system will show the sales order data in the appropriate container in an ALV format (fig. 1).

fig. – 1

Program Structure

Step I: Declare all necessary tables and structures
Step II: Declare the references to the different classes
Step III: Event class definition
Step IV: Putting the Event Class into Practice
Step V: The Choosing Screen
Step-VI: Subroutine to obtain the fundamental data for the tree model
Step VII: Design of the Screen
Step VIII: Module for creating different classes of objects. (In the output screen’s PBO)
Step IX: The event registration module. (In the output screen’s PBO)
Step X: The output processing module. (In the output screen’s PBO)

Step-I: Declare all required structures and tables

Tables: vbak,vbap,vbfa.

*&---------------------------------------------------------------------*
*&            Structures and Table Declarations
*&---------------------------------------------------------------------*
Data: ls_vbak type vbak,
lt_vbak type table of vbak,
ls_vbap type vbap,
lt_vbap type table of vbap.

Types: begin of ty_vbfa,
vbelv type vbfa-vbelv, "Preceding SD Document
posnv type vbfa-posnv, "Preceding SD Document Item Number
vbeln type vbfa-vbeln, "Subsequent SD Document
posnn type vbfa-posnn, "Subsequent SD Document Item Number
vbtyp_n type vbfa-vbtyp_n, "Subsequent Document Category
vbtyp_v type vbfa-vbtyp_v, "Preceding Document Category
end of ty_vbfa.

Data: ls_vbfa type ty_vbfa,
lt_vbfa type table of ty_vbfa.

Data: ls_vbfa_copy type ty_vbfa,
lt_vbfa_copy type table of ty_vbfa.

Types: begin of ty_vbak,
vbeln type vbak-vbeln,  "Contract Number
audat type vbak-audat,  "Document Date
ernam type vbak-ernam,  "Name of Person who Created the Object
auart type vbak-auart,  "Sales Document Type
end of ty_vbak.

Data: ls_vbak_cont type ty_vbak,
lt_vbak_cont type table of ty_vbak.

Step II: Declare the references to the different classes

*&---------------------------------------------------------------------*
*&            Type Reference of Various Classes
*&---------------------------------------------------------------------*
Data: ref_split type ref to cl_gui_splitter_container,
ref_cust  type ref to cl_gui_custom_container,
ref_alv1  type ref to cl_gui_alv_grid,
ref_alv2  type ref to cl_gui_alv_grid,
ref_cont1 type ref to cl_gui_container,
ref_cont2 type ref to cl_gui_container.
Data: ref_tree  type ref to cl_simple_tree_model.

Step – III: Definition of event class

*&---------------------------------------------------------------------*
*&                       Event Class
*&---------------------------------------------------------------------*
class lcl_event_handler definition.
public section.
methods: node_dc for event node_double_click of cl_simple_tree_model
importing node_key sender.
endclass.

Step – IV: Implementation of Event Class

class lcl_event_handler implementation.
method: node_dc.

Data: lt_children type tm_nodekey,
v_so        type vbeln,
v_item      type posnr.

Data: ls_layout type lvc_s_layo.
* 'sender' is an implicit event parameter that is provided by
* ABAP Objects runtime system. It contains a reference to the
* object that fired the event. You may directly use it to
* call methods of this instance.

CALL METHOD SENDER->NODE_GET_LAST_CHILD
EXPORTING
NODE_KEY       = node_key
IMPORTING
CHILD_NODE_KEY = lt_children.

* ‘Level_count’ in expand_node method determines in which level of the tree
* we want the double_click method to be triggered.

if lt_children is not initial.
CALL METHOD SENDER->EXPAND_NODE
EXPORTING
NODE_KEY            = node_key
LEVEL_COUNT         = 2.
endif.

split node_key at space into v_so v_item.

refresh: lt_vbap.

select * from vbap
into table lt_vbap
where vbeln = v_so.

if sy-subrc = 0.

ls_layout-grid_title = text-002.
ls_layout-zebra      = 'X'.
ls_layout-smalltitle = ''.
ls_layout-cwidth_opt = 'X'.

CALL METHOD REF_ALV2->SET_TABLE_FOR_FIRST_DISPLAY
EXPORTING
I_STRUCTURE_NAME              = 'VBAP'
IS_LAYOUT                     = ls_layout
CHANGING
IT_OUTTAB                     = lt_vbap.

CALL METHOD REF_ALV2->REFRESH_TABLE_DISPLAY.

endif.

endmethod.
endclass.

Step – V:  Selection Screen

*&---------------------------------------------------------------------*
*&                   Selection Screen
*&---------------------------------------------------------------------*
selection-screen: begin of block b1 with frame title text-001.
select-options: s_vbeln for vbak-vbeln, "Document Number
s_audat for vbak-audat, "Document Date
s_ernam for vbak-ernam. "Name who Created the Object
selection-screen: end of block b1.

Step-VI: Subroutine to obtain the fundamental data for the tree model

*&---------------------------------------------------------------------*
*&                   Start Of Selection
*&---------------------------------------------------------------------*
start-of-selection.
perform Get_Data.

*&---------------------------------------------------------------------*
*&      Form  GET_DATA
*&---------------------------------------------------------------------*
*       Get All the display relevant Data for Tree Structure
*----------------------------------------------------------------------*
FORM GET_DATA .

select vbeln audat ernam auart
from vbak
into table lt_vbak_cont
where vbeln in s_vbeln and
audat in s_audat and
ernam in s_ernam.

if sy-subrc <> 0.
message E001(ZMSG) with 'No Record Found' display like 'I'.
elseif sy-subrc = 0.

select vbelv posnv vbeln posnn vbtyp_n vbtyp_v
from vbfa
into table lt_vbfa
for all entries in lt_vbak_cont
where vbelv = lt_vbak_cont-vbeln and
vbtyp_n = 'C' and
vbtyp_v = 'G'.

if lt_vbfa is initial.
message E002(ZMSG) with 'No Subsequent Record Found' display like 'I'.
else.
select * from vbak
into table lt_vbak
for all entries in lt_vbfa
where vbeln = lt_vbfa-vbeln.

select * from vbap
into table lt_vbap
for all entries in lt_vbak
where vbeln = lt_vbak-vbeln.

endif.
endif.
ENDFORM.

Step – VII: Screen Design

call screen 0100.

* The container should be drawn as large as possible. Also, the Lines/columns in the attributes tab of the screen painter are to be filled with the value 240 to get the full-screen splitter container.

Step – VIII: Module for object creation of various classes. (In PBO of output screen)

Create one module in the flow logic of the screen.

*&---------------------------------------------------------------------*
*&      Module  OBJECT_CREATION  OUTPUT
*&---------------------------------------------------------------------*
*       Object Creation for Classes
*----------------------------------------------------------------------*
MODULE OBJECT_CREATION OUTPUT.

CREATE OBJECT REF_CUST
EXPORTING
CONTAINER_NAME    = 'SPLIT_CONT'.

CREATE OBJECT REF_SPLIT
EXPORTING
PARENT            = ref_cust
ROWS              = 1
COLUMNS           = 2.

CALL METHOD REF_SPLIT->GET_CONTAINER
EXPORTING
ROW       = 1
COLUMN    = 1
RECEIVING
CONTAINER = ref_cont1.

The SET_COLUMN_WIDTH method can be used to change the splitter container’s width. As needed, pass the breadth.

CALL METHOD REF_SPLIT->SET_COLUMN_WIDTH
EXPORTING
ID                = 1
WIDTH             = 22.

CALL METHOD REF_SPLIT->GET_CONTAINER
EXPORTING
ROW       = 1
COLUMN    = 2
RECEIVING
CONTAINER = ref_cont2.

CREATE OBJECT REF_TREE
EXPORTING
NODE_SELECTION_MODE   = cl_simple_tree_model=>node_sel_mode_single.

CALL METHOD REF_TREE->CREATE_TREE_CONTROL
EXPORTING
PARENT                = ref_cont1.

CREATE OBJECT REF_ALV2
EXPORTING
I_PARENT  = ref_cont2.

ENDMODULE.                 " OBJECT_CREATION  OUTPUT

Step – IX: Module for event registration. (In PBO of output Screen)

*&---------------------------------------------------------------------*
*&      Module  EVENT_REGISTRATION  OUTPUT
*&---------------------------------------------------------------------*
*       Double Click Event Registration

*§4a. Frontend registration(i):  get already registered tree events.
*................................................................
* The following four tree events registers ALV Tree in the constructor
* method itself.
*    - cl_gui_column_tree=>eventid_expand_no_children
* (needed to load data to frontend when a user expands a node)
*    - cl_gui_column_tree=>eventid_header_context_men_req
* (needed for header context menu)
*    - cl_gui_column_tree=>eventid_header_click
* (allows selection of columns (only when item selection activated))
*   - cl_gui_column_tree=>eventid_item_keypress
* (needed for F1-Help (only when item selection activated))
*
* Nevertheless you have to provide their IDs again if you register
* additional events with SET_REGISTERED_EVENTS (see below).
* To do so, call first method  GET_REGISTERED_EVENTS (this way,
* all already registered events remain registered, even your own):

* (If you do not these events will be deregistered!!!).
* You do not have to register events of the toolbar again.
*----------------------------------------------------------------------*
MODULE EVENT_REGISTRATION OUTPUT.
Data: lt_events type cntl_simple_events,
ls_event type cntl_simple_event.

Data: event_handler type ref to lcl_event_handler.

CALL METHOD REF_TREE->GET_REGISTERED_EVENTS
IMPORTING
EVENTS = lt_events.

ls_event-eventid = cl_simple_tree_model=>eventid_node_double_click.
append ls_event to lt_events.

CALL METHOD REF_TREE->SET_REGISTERED_EVENTS
EXPORTING
EVENTS                    = lt_events.

create object event_handler.
set handler event_handler->node_dc for ref_tree.

ENDMODULE.                 " EVENT_REGISTRATION  OUTPUT

Step – X: Module for output processing. (In PBO of output Screen)

*&---------------------------------------------------------------------*
*&      Module  PROCESSING_OUTPUT  OUTPUT
*&---------------------------------------------------------------------*
*       Processing Output of the Table
*----------------------------------------------------------------------*
MODULE PROCESSING_OUTPUT OUTPUT.

Data: ls_node type treemsnodt.

CALL METHOD REF_TREE->ADD_NODE
EXPORTING
NODE_KEY                = 'ROOT'
ISFOLDER                = 'X'
TEXT                    = 'Orders'
EXPANDER                = 'X'.

loop at lt_vbak into ls_vbak.

ls_node-node_key = ls_vbak-vbeln.

concatenate 'Sales Order#' ':' ls_vbak-vbeln
into ls_node-text
separated by space.

CALL METHOD REF_TREE->ADD_NODE
EXPORTING
NODE_KEY                = ls_node-node_key
RELATIVE_NODE_KEY       = 'ROOT'
RELATIONSHIP            = cl_simple_tree_model=>relat_last_child
ISFOLDER                = 'X'
TEXT                    = ls_node-text
EXPANDER                = 'X'.

endloop.

loop at lt_vbap into ls_vbap.

concatenate ls_vbap-vbeln ls_vbap-posnr
into ls_node-node_key
separated by space.

ls_node-relatkey = ls_vbap-vbeln.

concatenate ls_vbap-posnr ls_vbap-matnr
into ls_node-text
separated by space.

CALL METHOD REF_TREE->ADD_NODE
EXPORTING
NODE_KEY                = ls_node-node_key
RELATIVE_NODE_KEY       = ls_node-relatkey
RELATIONSHIP            = cl_simple_tree_model=>relat_last_child
ISFOLDER                = ''
TEXT                    = ls_node-text
EXPANDER                = ''.

endloop.
ENDMODULE.                 " PROCESSING_OUTPUT  OUTPUT

Change the design, but feel free to copy or refer to the included code. I would prefer to advise using the local class to help construct the complete report, or at the very least, using some modularization techniques. I utilized several PBO modules, which is strongly discouraged for any real-time object.

There are numerous different methods for creating tree topologies. There are a ton of documents available online. I chose the most straightforward method (the class name is, ironically, “cl_simple_tree_model”).Splitter containers have been extensively studied, although they are rarely utilized unless there are very particular needs.But all this claim is “Old wine in a new bottle,” that is all. I hope this eliminates our reluctance to use tree models and splitter containers.

Every post we write is the result of extensive planning, testing, and writing.It would be greatly appreciated by our team if you could forward this link to at least five friends or coworkers who you believe would find our content useful.In order to benefit everyone, keep our staff engaged, and ensure that our effort is not lost in the vast internet, we want our articles to be seen by as many people as possible.

Salesforce training modules

A World of History and Culture: Exploring the Past

The post OOP Report Applying ALV Tree Combination and Splitter first appeared on TECHNICAL GYAN GURU.

SAP Fiori Tutorial, It is one thing to grasp the idea and possess theoretical understanding of any technology; it is quite another to put that knowledge to use solving problems in real time.It is not enough to be good at racing games and expect to be a Formula 1 champion. Analyzing technical problems during Fiori App configuration can also be a little challenging and time-consuming if you haven’t worked directly on real applications.

But don’t be alarmed. I, Sumit from Invenio, am here to save the day for you!

While working on intricate real-world projects involving Fiori applications, I will attempt to assist application developers (ABAP and Frontend specialists) in comprehending and using various troubleshooting tools and techniques to speed up their analysis.

When configuring any configuration, we will verify the most frequently occurring error.

Since SAP Fiori development involves a number of infrastructure components, including back-end, front-end (gateway), web dispatched, UI application, etc., resolving such issues can be difficult, annoying, and time-consuming for novices. Furthermore, problems may arise in any of these elements.

So, the crucial query is:

Where do we begin when debugging Fiori problems?

In order to initiate front-end debugging and determine whether problems are present in the front-end or back-end components, developers frequently start by using the Well-Known Function Key F12 (or right-clicking and choosing INSPECT in the browser where the Fiori App is running). There are no problems shown in the console in our sample.

2 Verifying whether there are any errors in SAP Gateway is the next step. Depending on your gateway deployment method (Hub or Embedded), it could be your front-end or back-end system.

Use transaction “/IWFND/ERROR_LOG” to confirm whether Gateway Services has received any error log reports.

Thankfully, there have been no reported issues in this instance.

In the SAP Fiori launchpad, the next step is to use transaction “/UI2/FLIA” to verify that a provided INTENT (semantic object – action pair) has been assigned to a USER.

For a user, this report offers a summary of all of their intents. It lets you see which authorization role the purpose belongs to and whether a specific person is allocated to it.

The report’s results can be filtered according to the type of device (desktop, mobile, etc.).

The personalization layer is the default layer.

The check depends on the system. Launch the report in the system whose content you wish to check.

Check to see whether “Configuration error” for semantic “ZMat” and action “Create” exists.In this

After that, see if there is a “Customization error” for the Action “Create” and the Semantic “ZMat“.The customization error in this instance is reported as follows.

To examine the error message in more detail, select the error and then click Display.

Detailed Error Message: “Launchpad ZMM / transaction / ZMM01 does not exist in client 800”.

Transaction “/UI2/FLP_CONTCHECK” is another tool that developers may utilize to confirm Fiori Launchpad content. Here, developers can filter programs using packages. Let’s examine it more closely.

Developers can also use transaction “/UI2/FLP_CONTCHECK” to verify Fiori Launchpad content.

Developers can use packages to filter apps here. Let’s give it a closer look.

Under Configuration for Custom App ZMM, no errors have been recorded.

Verify the Customization aspect as well. The error message for the Catalog ZMM, which powers our unique application, is displayed below.

In this case, it is the same error that was encountered in Step 3.

See Also: Complete SAP ABAP for S/4HANA Tutorials

We now know the problem, more or less. Now is the moment to put an end to it and win the day!

Let’s investigate the meaning behind Launchpad Role “ZMM” and Launchpad Instance “transaction” alias “ZMM01”. The Launchpad role and instance that you set up in transaction “LPD_CUST” are the same.

LPD_CUST shows that both Role and Instance are kept alive.What’s wrong if the Role and Instance are configured?

Keep in mind that Target Mapping defines the launchpad role and instance, which may be accessed using transaction /n/UI2/FLPD_CUST (Fiori launchpad designer).

After choosing the Target Mapping, select “Configure.””.

It is obvious that Target Mapping maintains Role and Instance.

What then is the problem?

Where in the configuration are we making mistakes?

To unravel this mystery, you’ll need Sherlock Holmes’s powers of observation.

Semantic mapping and launchpad settings may be closely compared, and you’ll see that the instance is kept in Lower case Target Mapping (see screenshot above).We must keep it exactly as per the LPD_CUST setting in the same scenario.

Let’s make the modification to uppercase.

Save and open the app again. Success! It was successful!

You may think the error is a monster when you receive it. However, you could think it’s all for nothing once you understand the underlying problem. For the majority of typical problems, this is true. When we know the answer, the problem always seems really straight forward.

Coding and programming the fix is simple, as we often say. The majority of the work and time is spent determining the source and fundamental cause.

you may be interested in this Blog here:-

When Did I First Hear About SAP? A Journey Through Discovery

How can I change the color of the Langchain output agent ?

Making Your First Salesforce Appexchange: A Complete Strategy

The post SAP Fiori Tutorial. Part VI. How to Troubleshoot SAP Fiori Errors? first appeared on TECHNICAL GYAN GURU.

Understanding Core Data Services (CDS) Views

Core Data Services (CDS) are a framework provided by SAP for defining and consuming semantically rich data models. Unlike traditional database views, CDS views are designed to provide a higher level of abstraction and integrate seamlessly with SAP HANA’s advanced capabilities. They are essential for enabling real-time analytics and creating robust data models.

Key Features of CDS Views:

1. Semantic Layer: CDS views offer a layer of abstraction that describes the data in a business context, making it easier to interpret and use.
2. Performance Optimization: Built-in capabilities for performance optimization such as data buffering and aggregation.
3. Reusability: CDS views can be reused across various applications, reducing redundancy and ensuring consistency.

Integrating CDS Views with KPI Fiori Apps

Key Performance Indicators (KPIs) are critical for monitoring the health and performance of business processes. Fiori apps, with their user-friendly interface and real-time capabilities, provide a powerful platform for visualizing and interacting with KPIs. Integrating CDS views with KPI Fiori apps involves several key steps:

1. Defining CDS Views

To start, you need to define the CDS views that will serve as the data source for your KPIs. These views should encapsulate the relevant metrics and dimensions necessary for performance tracking.

Steps to Define CDS Views:

• Identify Requirements: Determine the specific KPIs and the data requirements for each. This includes understanding the key metrics, dimensions, and any necessary calculations.
• Create CDS Views: Use the SAP HANA Studio or Eclipse to define your CDS views. Utilize CDS annotations to enhance functionality, such as defining analytical capabilities or specifying data aggregations.

sqlCopy code@AbapCatalog.sqlViewName: 'ZMYKPI_VIEW'
@EndUserText.label: 'My KPI View'
define view Z_MY_KPI_VIEW as select from some_table {
    key field1,
    field2,
    sum(field3) as total_field3
}
group by field1, field2

2. Exposing CDS Views as OData Services

CDS views need to be exposed as OData services to be consumed by Fiori apps. This step bridges the gap between the backend data models and the frontend user interface.

Steps to Expose CDS Views:

• Create OData Service: Use SAP Gateway to create an OData service based on your CDS views. This involves defining the service, mapping the CDS view fields to the OData properties, and configuring any necessary metadata.
• Activate Service: Ensure that the OData service is activated and available for consumption. This is typically done through the SAP Gateway Service Builder (transaction SEGW).

abapCopy code@OData.publish: true
define view Z_MY_KPI_ODATA as select from Z_MY_KPI_VIEW {
    field1,
    field2,
    total_field3
}

3. Configuring KPI Tiles in Fiori Launchpad

With your OData service in place, the next step is to configure KPI tiles within the Fiori Launchpad. This involves defining how the KPIs are displayed and interacted with by end users.

Steps to Configure KPI Tiles:

• Create KPI Tile: Use the Fiori Launchpad Designer to create and configure KPI tiles. Specify the OData service as the data source and configure properties such as target values, thresholds, and visual representation.
• Set Up KPI Tile Properties: Define how the KPI values are calculated and displayed. This includes setting up alerts for threshold breaches and ensuring the KPI tiles provide actionable insights.

jsonCopy code{
    "type": "KPI",
    "dataSource": "/sap/opu/odata/sap/Z_MY_KPI_ODATA/",
    "targetValue": {
        "value": "total_field3",
        "format": "Number"
    },
    "thresholds": [
        {
            "value": "1000",
            "color": "Red"
        },
        {
            "value": "500",
            "color": "Yellow"
        }
    ]
}

4. Testing and Validation

Before rolling out your KPI Fiori apps, thorough testing is essential to ensure that the KPIs are accurate and the data is represented correctly.

Testing Checklist:

• Data Accuracy: Verify that the data in the KPI tiles matches the data from the CDS views.
• Performance: Test the performance of the OData service and KPI tiles to ensure they meet performance benchmarks.
• User Experience: Validate the usability of the KPI tiles in the Fiori Launchpad. Ensure they are intuitive and provide clear, actionable insights.

5. Continuous Monitoring and Improvement

Post-deployment, it’s crucial to continuously monitor and refine your KPIs and CDS views. This ensures that the KPIs remain relevant and the data continues to meet business needs.

Continuous Improvement Strategies:

• Monitor Performance: Regularly review the performance of KPI tiles and OData services. Optimize as necessary to maintain responsiveness and accuracy.
• Update KPIs: Adjust KPIs based on evolving business objectives and user feedback.
• Enhance Data Models: Refine CDS views to incorporate new business logic or data requirements as they emerge.

Best Practices for Using CDS Views in KPI Fiori Apps

To maximize the benefits of integrating CDS views with KPI Fiori apps, adhere to the following best practices:

1. Ensure Data Quality: High-quality data is essential for accurate KPIs. Regularly audit and cleanse data to maintain integrity.
2. Optimize Performance: Use efficient CDS view definitions and optimize OData services to ensure swift data retrieval and presentation.
3. User-Centric Design: Focus on user experience by designing KPI tiles that are intuitive and provide clear, actionable insights.
4. Documentation: Maintain thorough documentation of CDS views, OData services, and KPI configurations to facilitate easier maintenance and troubleshooting.

Conclusion

Integrating CDS views with KPI Fiori apps for Smart Business Services empowers organizations to harness the full potential of their data. By following the outlined steps and best practices, businesses can achieve enhanced visibility into performance metrics, drive better decision-making, and ultimately, foster improved operational efficiency.

Embracing this approach not only aligns with modern data management principles but also sets the stage for continued innovation and success in an increasingly data-driven world.

you may be interested in this blog here:-

Benefits of Using Salesforce Nonprofit Cloud for Event Planing

ABAP for SAP HANA. ALV Report On SAP HANA – Opportunities And Challenges

The post Part 11 of Core Data Services: How Do I Use CDS View in the KPI Fiori Apps for Smart Business Services? first appeared on TECHNICAL GYAN GURU.

In today’s digital era, optimizing user experience is crucial for enhancing business processes and operational efficiency. SAP Fiori represents a significant advancement in this realm, offering a modern, role-based approach to user interfaces within SAP systems. This blog post provides a comprehensive overview of SAP Fiori from a strategic, space-level perspective, exploring its core functionalities, benefits, and integration possibilities. By understanding SAP Fiori at this high level, organizations can better appreciate how it transforms user interaction and boosts overall productivity.

What is SAP Fiori? Unpacking the Concept

At its core, SAP Fiori is a design framework that redefines the user experience for SAP applications. By integrating modern design principles with SAP’s powerful backend systems, SAP Fiori offers a streamlined, intuitive interface that significantly enhances usability. It focuses on delivering a consistent and responsive experience across various devices, whether on desktop, tablet, or mobile.

SAP Fiori is built on the principle of simplicity, aiming to simplify user interactions with complex SAP systems. It achieves this by providing role-based access, which ensures that users see only the information and functionalities relevant to their specific roles. This tailored approach not only improves efficiency but also reduces the learning curve associated with traditional SAP interfaces.

Exploring the SAP Fiori Apps Library: A Treasure Trove of Functionality

The SAP Fiori Apps Library is a central component of the SAP Fiori ecosystem, offering a comprehensive repository of pre-built applications designed to meet diverse business needs. This library categorizes applications into three main types: transactional apps, analytical apps, and fact sheets.

Transactional apps facilitate daily business tasks such as processing orders or managing inventory. They streamline these processes by offering a simplified and user-friendly interface. Analytical apps, on the other hand, provide insights and reports based on real-time data, enabling informed decision-making. Fact sheets offer detailed information on business objects, such as customers or products, giving users a comprehensive view of critical data.

By leveraging the SAP Fiori Apps Library, organizations can quickly identify and deploy applications that align with their business requirements. This library not only accelerates implementation but also ensures that users have access to the tools they need to perform their roles effectively.

Navigating the SAP Fiori Library: An Essential Guide

The SAP Fiori Library, accessible via the SAP Fiori Launchpad, serves as the gateway to exploring and managing SAP Fiori applications. This library provides a user-friendly interface that allows users to search for, explore, and launch various applications based on their roles and needs.

Users can browse through the SAP Fiori Library by categories or use the search functionality to find specific apps. Each application in the library is accompanied by detailed information, including its purpose, functionalities, and prerequisites. Administrators can also use the library to manage application deployment, configure settings, and monitor performance.

Effective navigation of the SAP Fiori Library is crucial for maximizing the benefits of SAP Fiori. By familiarizing themselves with the library’s features and functionalities, users and administrators can ensure a seamless experience and optimize their use of SAP Fiori applications.

The Role-Based Approach: Tailoring SAP Fiori to User Needs

A defining feature of SAP Fiori is its role-based approach, which tailors the user experience to specific roles within an organization. This approach ensures that users see only the information and functionalities relevant to their responsibilities, reducing complexity and improving efficiency.

For instance, a finance manager might have access to applications related to financial reporting and budget management, while a sales representative would see applications focused on sales orders and customer interactions. This targeted presentation of information helps users focus on their tasks without being overwhelmed by irrelevant data or features.

By adopting a role-based approach, SAP Fiori enhances productivity and streamlines workflows. Users can complete tasks more efficiently, and organizations can benefit from a more organized and user-centric interface.

SAP Fiori Login: Accessing Your Applications Securely

Accessing SAP Fiori applications involves a straightforward login process designed to ensure secure and personalized access. The SAP Fiori login page is the entry point to the SAP Fiori Launchpad, where users can access their assigned applications and services.

Users need to enter their credentials, including a username and password, to log in. Depending on the organization’s security protocols, additional authentication methods such as single sign-on (SSO) or two-factor authentication (2FA) may be required. Once logged in, users are directed to the SAP Fiori Launchpad, where they can access their role-specific applications and begin their tasks.

The SAP Fiori login process is designed to provide both security and convenience, ensuring that users can easily access their applications while maintaining the integrity of the system.

Design Principles of SAP Fiori: Enhancing User Experience

SAP Fiori’s design principles are foundational to its success in transforming user experiences. These principles include simplicity, coherence, and responsiveness, each contributing to a more effective and engaging interface.

Simplicity is about reducing complexity by presenting only the necessary information and actions. Coherence ensures a consistent look and feel across all applications, making it easier for users to navigate and use different apps. Responsiveness guarantees that applications work seamlessly across various devices and screen sizes.

By adhering to these design principles, SAP Fiori delivers a user experience that is both visually appealing and highly functional. This focus on user-centric design helps organizations achieve higher levels of user satisfaction and operational efficiency.

Integrating SAP Fiori with Existing Systems: Best Practices

Integrating SAP Fiori with existing SAP systems is a critical step in realizing its full potential. Effective integration ensures that SAP Fiori applications can interact seamlessly with other SAP modules and data sources, providing a unified user experience.

Organizations should work closely with their IT teams or SAP consultants to facilitate integration. This process may involve setting up interfaces, configuring data exchanges, and testing application performance. Successful integration allows organizations to leverage SAP Fiori’s capabilities fully, enhancing their overall SAP ecosystem.

Best practices for integration include thorough planning, comprehensive testing, and ongoing monitoring. By following these practices, organizations can ensure that their SAP Fiori implementation is smooth and effective.

Future Trends in SAP Fiori: What to Expect

As technology continues to evolve, so too does SAP Fiori. Future trends in SAP Fiori may include advancements in artificial intelligence (AI), machine learning, and advanced analytics. These innovations aim to further enhance user experience by providing intelligent recommendations, predictive insights, and automated workflows.

Additionally, SAP Fiori is likely to continue its focus on mobile and cloud-based solutions, enabling users to access applications and data from anywhere and on any device. Staying informed about these trends will help organizations remain competitive and fully leverage the capabilities of SAP Fiori.

Conclusion

SAP Fiori represents a significant leap forward in user experience design for SAP applications. By providing a modern, role-based, and responsive interface, SAP Fiori enhances productivity and user satisfaction. Understanding SAP Fiori from a high-level perspective helps organizations appreciate its transformative impact on business operations.

From exploring the SAP Fiori Apps Library to integrating with existing systems, SAP Fiori offers a range of features and benefits designed to optimize user interactions and streamline processes.

you may be interested in this blog here

Discover Joy Worksheet for Pre Primary English PDF Free Download

Getting the Best Salesforce Partner: A Tutorial for Business Growth

The post “A Strategic View of SAP Fiori: Insights from a Space Level Perspective” first appeared on TECHNICAL GYAN GURU.

Beginners of ABAP CDS who wish to continue with the ABAP Programming Model in SAP Fiori without having to navigate and bounce between pages would find this tutorial to be helpful. However, if you want to go deeper into it, we strongly advise you to take our Core Data Services training series.

What transpires when CDS View is created?

When a CDS view is activated, two artifacts are produced: a CDS View Entity, which is a SAP HANA view on the database, and a corresponding SQL View, which is the Data Dictionary (DDIC) view in the ABAP Dictionary (@AbapCatalog.sqlViewName). With the object repository entry R3TR DDLS, just the CDS View definition is sent. Different sorts of annotations can be used to augment CDS views, which are built using CDS’s Data Definition Language (DDL), to cover various application scenarios.

Navigate to transaction SE11; the above-highlighted view will appear in the ABAP DDIC view options.

CDS Views’ naming convention

The following naming conventions are used to categorize CDS Views:

Private View (P_)

View Interface (I_)

Using Perspective (C_)

Exclusive Perspective

Private Views are made for internal use and will be accessible everywhere. Developers can build associations with this Private view or utilize it to develop CDS views.SAP does, however, advise users not to use Private views as they are not safer.In the future, certain columns might be added or removed in a way that would hinder our development because it depends on these viewpoints.

Please keep in mind that this does not mean we should never embrace their opinions. Steer clear of consumption if possible.

View of the Basic Interface

View of the Composite Interface

From a technical standpoint, Basic and Composite views differ in:

Master data is contained in Basic View, whereas both Master and Transactional data are contained in Composite View.Using I_ conventions, the Basic and Composite Interface views are identified.

View of Consumption

Interface views serve as the foundation for this view. This view serves as the data model’s pre-made solution. It is also much simpler to design and use a Fiori App using these views. It can also be used analytically; BI reports, for example, can be created. It is easy to develop if SAP already provides the Consumption views.

Key Features of CDS:

1. Semantic Layer: CDS views offer a business-oriented abstraction layer over raw data, making it easier for developers and end-users to interact with complex data structures.
2. Performance Optimization: Leveraging SAP HANA’s in-memory processing, CDS views are designed to optimize performance, enabling fast and efficient data retrieval and manipulation.
3. Reusability: CDS views can be reused across different applications, reducing redundancy and ensuring consistency in data representation.

Practical Application of CDS Views

Implementing CDS views involves several steps, each crucial for ensuring that data is modeled and utilized effectively:

1. Defining CDS Views: The first step is to define the CDS views using the ABAP Development Tools (ADT) in SAP HANA Studio or Eclipse. This involves creating a CDS view definition that specifies the data source, fields, and any necessary calculations or aggregations.

sqlCopy code@AbapCatalog.sqlViewName: 'ZMY_CDS_VIEW'
@EndUserText.label: 'My CDS View Example'
define view Z_MY_CDS_VIEW as select from some_table {
    key field1,
    field2,
    sum(field3) as total_field3
}
group by field1, field2

2. Exposing CDS Views as OData Services: To integrate CDS views with SAP Fiori apps, they need to be exposed as OData services. This is done using the SAP Gateway, which allows Fiori apps to consume the data via standard web protocols.

3. Integrating with Fiori Apps: Once the OData service is set up, it can be consumed by Fiori apps. Developers configure Fiori tiles and applications to use the OData services, ensuring that the data presented aligns with the business requirements.

4. Testing and Validation: Thorough testing is essential to ensure that the CDS views deliver accurate data and perform well under different scenarios. This includes validating data accuracy, performance, and the user experience in Fiori apps.

Conclusion

Core Data Services (CDS) views are a fundamental component of the SAP Fiori ABAP Programming Model, offering a powerful framework for data modeling and integration. By providing a semantic layer over raw data, CDS views enable developers to create efficient, real-time, and user-centric applications. Their ability to simplify data modeling, optimize performance, and enhance user experience makes them indispensable for modern SAP Fiori development.

Implementing CDS views effectively requires careful planning and execution, from defining the views to integrating them with Fiori apps. Embracing CDS views not only streamlines data management but also ensures that SAP Fiori applications deliver meaningful and actionable insights to users. As organizations continue to evolve and leverage advanced technologies, understanding and utilizing CDS views will remain a key factor in achieving success and driving innovation in the SAP ecosystem.

you may be interested in this Blog Here

Can I become full stack developer in 3 months?

Salesforce Incident Management: Streamlining Issue Resolution

How the Digital Services Act is Shaping the Future of the SAP Community

The post SAP Fiori ABAP Programming Model – 2 – CDS – Overview first appeared on TECHNICAL GYAN GURU.

Let’s get our application’s data model started. Generally speaking, it is excellent practice to build a package and include the data model that CDS views will construct.

Make a Package
Create a package using the SE80 transaction as shown below;

Build a data model with CDS Views.

Assume for the moment that the airline industry data model exists. The airline industry will own information pertaining to carriers and flight schedules.

Now that we have this bare minimum requirement, let’s get the data model built. Three common database tables are used in this scenario:

SCARR: Airline Details.
SFLIGHT: Information about flights.
Flight schedule information for SPFLI.
We will develop three distinct basic Interface(I_) views using the three standard tables mentioned above.

How to Make CDS Views

Verify that the ADT components are correctly installed in Eclipse and connect the SAP system to the Eclipse environment.
Start generating CDS Views in the created package by performing a right-click on the Package and selecting New -> Other ABAP Repository object, as demonstrated below.

3. The wizard for creating an ABAP repository object will then show up. Enter “Core” as the first character in the wizard’s filter box.

4. Click Next after choosing Data Definition from the filtered list.

Click Next after entering the Name and Description for the data definition.

6. Select Define View, then press the Finish button.

7. The following Data Definition will be created:

Type the SQL View name to be generated in @ABAPCatalog.sqlViewName and replace the data_source_name with SCARR (in our example, this is ZAPF_SCARR in the first line). Next, add the elements that must be visible in the view.

Confirm, save, and turn on the data definition. As stated in the previous chapter, DDL SQL View will be activated after

The essential perspectives are now available. To prepare the data model for the Fiori App, let’s further transform these views into Composite views and additionally construct Consumption views (C_). The data model that we are attempting to create and offer as a Fiori app through an OData service is shown below.
Combined Views.

To create Composite views, let’s execute Association between the Basic views. Join us on the airline (ZAPF_I_AIRLINE) and flight information (ZAPF_I_FLIGHTS) associations. For the remaining views, we then create associations as shown in the Data Model diagram above. The snapshot showing the relationship between the views is shown below.

Views on Consumption

We will construct Consumption views with selection on these composite views and then association on all three Consumption views, much like Composite Views.

n the ABAP Programming Model for SAP Fiori, Core Data Services (CDS) views play a pivotal role in defining and managing data structures. CDS views are essentially SQL-based views that offer a powerful and flexible way to model data in the SAP system. They enable developers to define complex queries and data relationships in a reusable and maintainable manner. By using CDS views, you can enhance data access performance and leverage advanced features like annotations and access control.

Conclusion:

Mastering CDS views is crucial for effective SAP Fiori development. They provide a robust framework for structuring data, which is essential for creating dynamic and efficient Fiori applications. Understanding how to create and utilize CDS views will significantly streamline your development process and improve the performance of your SAP solutions.

you may be interested in this blog here:-

What is ERP?

How do I become a Oracle SQL Developer?

Salesforce course with placement in Pune

The post ABAP Programming Model – 3 – Creating CDS Views in SAP Fiori first appeared on TECHNICAL GYAN GURU.

The introduction of business object annotations to Composite interface views is necessary since Basic Interface views must also be reused in other applications. We need to add multiple @ObjectModel annotations to the three composite CDS views in order to construct a BOPF business object based on those views.

We need to add the header level annotations in the Airline root view (ZAPF_I_AIRLINE).

Model @ObjectModel.model@ObjectModel.composition Category:#BUSINESS_OBJECTRoot:actual
@ObjectModel.transactionalProcessingAllowed:actual
The object model writes “SCARR” in the ActivePersistence field.Activated: Yes
@ObjectModel.removeActivated: Yes
@ObjectModel.updateActivated: Yes
describe view ZAPF_I_AIRLINE… {…. }

The list of annotations for BOPF Business Objects is shown below.

Let’s add the BOPF BO annotations mentioned above to our airline model.

On activation of the transactional or business object views, the BOPF runtime will generate a business object together with several structures and table types based on the CDS view field structures. The generated BOPF object has the same name as the
root CDS view, in our case, ZAPF_I_AIRLINE.

To enable our existing consumption views for transactional processing via the generated BOPF business object, we must add some of the @ObjectModel annotations on the header level. To the Airline Consumption view (ZAPF_C_AIRLINE), we must add the annotations given as below

...
@ObjectModel.transactionalProcessingDelegated:true
@ObjectModel.compositionRoot:true
@ObjectModel.createEnabled:true
@ObjectModel.updateEnabled:true
@ObjectModel.deleteEnabled:true
...
define view ZAPF_C_AIRLINE
...
{
...
}

We should mark the view as the root view of our hierarchy node structure by introducing @ObjectModel.compositionRoot: true. Additionally, we must enable all transactional operations separately because they are already known from the Interface views. The only new annotation is the @ObjectModel.transactionalProcessingDelegated: true, which indicates that transactional processing is delegated to the transactional runtime of the underlying view. In our case, ZAPF_I_AIRLINE is the business object and view. Moreover, we must also specify the same association type annotations as in the underlying views, from Airline to Flights Info. and vice-versa.

Additionally, we have to add annotations to Flights Info. Consumption view (ZAPF_C_FLIGHTS) and Flight Schedule Consumption view(ZAPF_C_FLI_SCHED), to enable transactional processing delegation.

...
@ObjectModel.transactionalProcessingDelegated:true
@ObjectModel.createEnabled:true
@ObjectModel.updateEnabled:true
@ObjectModel.deleteEnabled:true
...
define view ZAPF_C_FLIGHTS
...
{
...
}

Once all the BOPF BO annotations are added, our Fiori App will look like below.

Let’s insert data with below details in all three views.

The results of the save procedure are shown below.

We had no trouble saving entities into the appropriate table thanks to BOPF’s assistance. Let’s go into more detail about the other functions that BOPF offers in the upcoming chapters.

you may be interested in this blog here:-

Safeguarding Your Salesforce Journey: A Comprehensive Guide to Backup and Recovery

Show and Download PNG JPG PDF Archive in Fiori Client Android with outsider Application for Zoom/extra choices

What is KPI in SAC?

The post SAP Fiori – 8 ABAP Programming Model – Creating Transactional Applications – CRUD Operations with BOPF first appeared on TECHNICAL GYAN GURU.

SAP Fiori , In the earlier chapters on using BOPF to enable CRUD activities, we learned how to directly fetch, create, update, modify, and delete data from databases.However, there won’t be a direct update or insert into the database given our business scenarios.Certain frameworks must be used to manage the business logic.

Draft functionality is necessary in order to handle those logic at runtime and push the data into the database in the correct format. The most crucial feature is that Lock can be enabled automatically without the need for explicit coding or the establishment of Lock Objects.

Now let’s incorporate the Draft feature into our airline data model.The BOPF’s active persistence annotation will be replaced by the draft functionality shown in the code below.The system is being told to temporarily store the data in tables that support drafts. Like parking any document in a typical ECC t-code, that is. When the actual Save operation is carried out on the user interface, the data saved in the draft tables will be committed into actual persistent tables.

To enable Draft functionality, delete the @ObjectModel annotation by following the code below.write “SCARR” as the ActivePersistence.

Any name can be entered for the Draft table name in the annotation of @ObjectModel.writeDraftPersistence:’ZSCARR’. The Draft table will be established after activation. The annotations that were applied to various data models for Draft functionality are shown below.

The generated BO will have a draft handling class and database table, as seen below. In order to ensure that the data is saved into the database in the correct format, more business logic might be included before the database table is actually committed.

Data is moved from draft persistence to active persistence during this phase, which is known as the “Save Sequence Phase.”

Similarly, other nodes will also have their respective Draft tables in it. But there will be only one Draft handling class such that data from child nodes are retrieved by retrieve_by_association() method in the BOPF framework generated class.

In a similar manner, the Draft tables of the other nodes will also be present. However, the BOPF framework-generated class will only contain one Draft handling class where the retrieve_by_association() method is used to retrieve data from child nodes.

Bridging the Clouds: Unleashing the Power of Salesforce and Heroku Integration

What is custom web application?

Fiori App – An Introduction from an ABAPer

The post ABAP Programming Model for SAP Fiori – 11 – Enabling Draft Functionality for Transactional Apps first appeared on TECHNICAL GYAN GURU.