SAP SE (NYSE:NYSE:SAP) Q1 2024 Earnings Call Transcript April 22, 2024 5:00 PM ETCompany ParticipantsAnthony Coletta - Chief Investor Relations...

SAP SE (SAP) Q1 2024 Earnings Call Transcript | Seeking Alpha

Barron&#x27;s is a leading source of financial news, providing in-depth analysis and commentary on stocks, investments and how markets are moving across the world.

SAP Stock Rises on Earnings Report. What Happened.

Shares of software provider SAP SE (NYSE:SAP) (DE:SAP) were little changed in after-hours trading after the company reported earnings for its first quarter of Fisca...

SAP SE (NYSE:SAP) Misses Earnings Expectations, Shares Little Changed - TipRanks.com

For the three months ended Mar. 31, SAP reported adjusted earnings of €0.81 per share, missing the consensus estimate of €1.06 per share. Revenue came in at €8.04 billion, also below the €8.63 billion expected by analysts.

SAP rises as Q1 print delivers 'solid update against elevated expectations' By Investing.com

Enterprise application software company SAP has introduced artificial intelligence advances for its supply chain solutions.

SAP Debuts New AI Offerings for Supply Chains

SAP SE (NYSE:SAP) Q1 2024 Earnings Call Transcript April 22, 2024 SAP SE isn’t one of the 30 most popular stocks among hedge funds at the end of the third quarter (see the details here). Operator: Welcome, and thank you for joining the SAP Q1 2024 Financial Results Conference Call.

SAP SE (NYSE:SAP) Q1 2024 Earnings Call Transcript

SAP earnings for Q1 2024 showed rises in cloud revenue and healthy cloud backlog, but the company must keep customers in the fold to drive future growth.

SAP earnings for Q1 indicate strong cloud growth | TechTarget

With its breadth of business applications, services, database and technology, SAP is the world's leading provider of enterprise software and services

What is a Sap Temporary  License Keys? An SAP temporary license key is a license used to activate SAP software that can only be used for a limited period of time. These keys can be used for evaluation purposes or during a system migration. They are temporary solutions and usually expire after a certain period of time. How to get the Sap BO Temporary License keys? Temporary keys: The SAP Support Portal provides temporary Business Objects license keys in case of any error while creating a permanent license key. You can download these keys by logging on to the link on the Support Portal and selecting the "Get Temporary License Key" link. These temporary license keys are valid for a maximum of 90 days. www.service.sap.com/licensekey Method 1: Manual download Open the URL and click here to download a file called "bobj-temp-license-key.zip": www.service.sap.com/licensekey After unzipping, there is a pdf file named "SAP Analytics Emergency License Key Process", in which you can find the License Key you need. Method 2: Automate the process of getting Sap Temporary keys using Python Download bobj-temp-license-key.zip You can use the library to download the zip file directly and save it in a specific path. requests import requests
import os

# Define the URL of the zip file
zip_file_url = 'https://support.sap.com/content/dam/support/en_us/library/ssp/my-support/keys/bobj-temp-license-key.zip'

# Define the folder path where you want to save the zip file.
download_zip_path = r"C:\\Users\\USERNAME\\Projects\\download_zip"

# Ensure the download folder exists
os.makedirs(download_zip_path, exist_ok=True)

# Create the full path for the zip file
zip_file_path = os.path.join(download_zip_path, 'bobj-temp-license-key.zip')

# Send a GET request to the URL and save the content to the zip file
response = requests.get(zip_file_url, stream=True)
with open(zip_file_path, 'wb') as zip_file:
    for chunk in response.iter_content(chunk_size=128):
        zip_file.write(chunk)

print(f"Zip file downloaded to: {zip_file_path}") Unzip the zip file to get the pdf The SAP Temporary Keys are saved in the PDF file, which you need to extract from the zip file first. You can use to obtain the information. zipfile import zipfile

# zip the zip file into 'bobj-temp-license-key'
file_path_zip = r"{}/bobj-temp-license-key.zip".format(download_zip_path)

if os.path.exists(file_path_zip):
    zip_file = zipfile.ZipFile(file_path_zip)
    zip_file.extractall(keys_path)
    zip_file.close()

# you can get the path of the pdf after unzip
file_path_pdf = "..." Get the required Licence Key from the pdf file. Take SAP BusinessObjects Temporary Licence Key as an example; the Licence Key is located on the second page of the pdf after the "CPU 4.2" field; after testing to determine the SAP BusinessObjects Temporary Licence Key, the Licence Key is located on the second page of the pdf after the "CPU 4.2" field, after testing to determine the SAP BusinessObjects Temporary Licence Key. The Licence Key is located after the "CPU 4.2" field on the second page of the pdf: import PyPDF2
import os

# Get SAP BusinessObjects Tempory Licence Key
def get_key_from_text(text):
    start = text.find('CPU 4.2') + 8
    return text[start:start + 32]

# file_path_pdf is the path of the pdf in the previous step 
if os.path.exists(file_path_pdf):
    pdf_file = open(file_path_pdf, 'rb')
    pdf_reader = PyPDF2.PdfReader(pdf_file)
    page = pdf_reader.pages[1]
    text = page.extract_text()
    latest_key = get_key_from_text(text)
    pdf_file.close() Automate Updating Process If you need to update the license key every 90 days, you can save the license key in a txt file and compare it with the locally saved license key after you successfully get the latest license key, if latest_key! If latest_key != current_key, then replace latest_key with current_key to ensure that the latest license key is always saved in the txt file. if os.path.exists(file_path_pdf):
    pdf_file = open(file_path_pdf, 'rb')
    pdf_reader = PyPDF2.PdfReader(pdf_file)
    page = pdf_reader.pages[1]
    text = page.extract_text()
    latest_key = get_key_from_text(text)
    pdf_file.close()
    if latest_key != current_key:
        with open(current_key_txt_path, 'w') as file:
            file.write(latest_key)
        print("license updated, latest license", latest_key)
    else:
        print("license didn't update, current license:", latest_key)
else:
    print("PDF is not exists") Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn

How to Use Python Automatically Get the Sap BO Temporary License keys?

Automating SAP GUI with PyAutoGUI involves using the Python package to simulate mouse clicks and keyboard inputs, allowing for navigation of the SAP system and extraction of data. It offers the advantage of not requiring extra rights and permissions, but may be less efficient and require more maintenance. This method is best for situations where access to APIs or databases is restricted and there is a need to automate tasks within the SAP GUI environment. Solution The solution involves two main parts. The first part focuses on automating SAP Logon, while the second part involves simulating clicks and typing using PyAutoGUI. To achieve this, the process of manually downloading data from SAP GUI is replicated by utilizing PyAutoGUI to simulate all necessary clicking and typing actions. Step 1: Automating SAP Logon open saplogon.exe this code uses package to open the saplogon.exe that has been installed on your Windows computer. If the installed in another path, feel free to replace it. subprocess saplogon.exe import subprocess

# open SAP GUI
sap_logopn = r"C:\Program Files (x86)\SAP\FrontEnd\SAPgui\saplogon.exe"
subprocess.Popen(sap_logopn) maximize the window Maximizing the window will be beneficial for the next step, as we need to specify precise coordinates for each click and typing area. This will ensure greater accuracy and efficiency in our task. After opening the , we can use the shortcut + to maximize the SAP GUI. In Python, the code to achieve this using the library is . saplogon.exe Win Up pyautogui pyautogui.hotkey('win', 'up') import pyautogui

# maximize the window
pyautogui.hotkey('win', 'up') Log On after opening the and maximizing the window, we need to click the button and then type in your User and Password to login in. saplogon.exe Log On Auto Clicking Lon On Button Hover over the button and run the following code to print the coordinates. Then use the printed values to define the variables and . Log on log_on_button_x log_on_button_y x, y = pyautogui.position()
print("The current position of the mouse is: X-axis {} and Y-axis {}.".format(x, y)) log_on_button_x = x
log_on_button_y = y
pyautogui.click(log_on_button_x , log_on_button_y) Typing User and Password Hover over the Client(optional), User and Password and use the same method to get the coordinates of the typing area. x, y = pyautogui.position() is used to simulate clicking on specific coordinates on the screen, and is used to type the username and password. pyautogui.click pyautogui.typewrite Remember to adjust the coordinates (x, y) according to your specific scree size. Additionally, you may need to add small delays using to ensure that each action is executed properly. time.sleep # client
client_x = 'client_x'
client_y = 'client_y '
pyautogui.moveTo(x=client_x, y=client_y, duration=0.25)
time.sleep(1)
pyautogui.click(client_x, client_y)
time.sleep(1)
pyautogui.hotkey('ctrl', 'a')
time.sleep(1)
pyautogui.press('delete')
pyautogui.typewrite('client')
time.sleep(2)

# user
user_x = 'user_x'
user_y = 'user_y'
pyautogui.click(user_x, user_y)
pyautogui.typewrite('account')
time.sleep(2)

# password
password_x = 'password_x'
password_y = 'password_y'
pyautogui.click(password_x, password_y)
pyautogui.typewrite('password')
time.sleep(2)

# login in 
pyautogui.press('enter') When the default language on your computer is not English, it may cause an error in the login process. You can use the following code to set your language to English. from win32api import SendMessage
from win32con import WM_INPUTLANGCHANGEREQUEST
from win32gui import GetForegroundWindow

SendMessage(GetForegroundWindow(), WM_INPUTLANGCHANGEREQUEST, 0, 0x4090409) == 0 Step 2: Simulating Clicks and Typing with PyAutoGUI Typing TCODE After logging in successfully, the next step is to enter the transaction code (tcode). def type_tcode(tcode, tcode_x, tcode_y):
    pyautogui.click(tcode_x, tcode_y)
    time.sleep(2)
    pyautogui.typewrite(tcode)
    time.sleep(2)
    pyautogui.press('enter') individual filters and export the data You can use to simulate individual filters by following the same logic as the first step. First, obtain the coordinates of the filters and then use to simulate the necessary operations. If you need to press , , or , you can use . If the report in SAP requires a significant amount of time to run, be sure to use to allow for ample time. pyautogui pyautogui enter delete right pyautogui.press('enter') time.sleep() Additionally, if you want to extract data from the report, you can use to locate and click on the necessary fields or buttons to export the data. After exporting the data, you can use Python libraries such as to manipulate the data as needed. Using , you can automate the process of generating reports in SAP by simulating mouse and keyboard inputs to navigate the SAP interface and extract the required information. This can save significant time and effort by streamlining the reporting process and reducing the need for manual input. pyautogui pandas pyautogui Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn Also published . here

How to Automate SAP Report Extraction with PyAutoGUI

In the realm of business intelligence and data analytics, SAP BusinessObjects stands tall as a powerful tool, empowering organizations to transform raw data into actionable insights. While its capabilities are robust, accessing and managing data programmatically can offer even greater flexibility. This blog post delves into the world of SAP BusinessObjects and Python, demonstrating a step-by-step approach to retrieve the list of documents effortlessly. Why This Matters In SAP BusinessObjects, years of operation can result in a cluttered mess of documents and folders. Cleaning up this chaos is crucial for data teams. By using Python to retrieve the details like path and last modified date and status for all documents, you gain a powerful tool. Python Solution Part 1: Authentication To initiate the authentication process, please replace the placeholder values for "username," "password," and "localhost" with your specific configuration details. import requests
import pandas as pd
import xml.etree.ElementTree as ET

# define the login request parameters
username = 'username'
password = 'password'
localhost = 'localhost'

auth_type = 'secEnterprise'
login_url = 'http://{}:6405/biprws/logon/long'.format(localhost)
login_data = f'<attrs xmlns="http://www.sap.com/rws/bip"><attr name="userName" type="string">{username}</attr><attr name="password" type="string">{password}</attr><attr name="auth" type="string" possibilities="secEnterprise,secLDAP,secWinAD,secSAPR3">{auth_type}</attr></attrs>'
login_headers = {'Content-Type': 'application/xml'}

# send the login request and retrieve the response
login_response = requests.post(login_url, headers=login_headers, data=login_data)

# parse the XML response and retrieve the logonToken
root = ET.fromstring(login_response.text)
logon_token = root.find('.//{http://www.sap.com/rws/bip}attr[@name="logonToken"]').text
api_headers = {'Content-Type': 'application/xml', 'X-SAP-LogonToken': logon_token} The code focuses on the initial authentication process, forming a secure connection to the server. User credentials, server details, and authentication type are configured, and a POST request is made to the specified login URL. The XML response from the server is parsed to extract the crucial . This token is then employed to construct headers for subsequent API requests, ensuring authenticated access to SAP BusinessObjects. logonToken Part 2: Data Retrieval and DataFrame Creation Previewing Retrieved Data: First Document's Name As we venture into data retrieval from SAP BusinessObjects, a peek at the obtained information reveals its structure. This Python snippet fetchs all the information about documents from the server. If you run the code, it will print the name of the first document. url = "http://{}:6405/biprws/raylight/v1/documents/".format(localhost)
response = requests.get(url,api_headers)
root = ET.fromstring(response.text)

first_docu_key = root.findall('document')[0][2].tag
first_docu_item = root.findall('document')[0][2].text
print(first_docu_key, ":", first_docu_item) Data Transformation Functions: Transform to DataFrame The Python functions, and , work together to simplify SAP BusinessObjects data retrieval. The first function transforms XML data into a structured pandas DataFrame, capturing document attributes. The second function efficiently handles scenarios with documents exceeding a single request's limit by appending multiple DataFrames. Collectively, these functions streamline the conversion of XML to DataFrame and provide an easy solution for handling a large number of documents. get_dataframe_from_response get_all_dataframe def get_dataframe_from_response(response):
 # Parse the XML data
 root = ET.fromstring(response.text)
 # Extract the data into a list of dictionaries
 res = []
 for item in root.findall('document'):
 doc_dict = {}
 for elem in item.iter():
 if elem.text is not None:
 doc_dict[elem.tag] = elem.text
 res.append(doc_dict)
 # Convert the list of dictionaries to a pandas dataframe
 df = pd.DataFrame(res)
 return df

def get_all_dataframe(url):
 documents = []
 for i in range(50):
 offset = i * 50
 url_offset = url + "?offset={}&limit=50".format(offset)
 response = requests.get(url_offset, headers=api_headers)
 df = get_dataframe_from_response(response=response)
 if df.empty:
 break
 else:
 documents.append(df)
 dataframe = pd.concat(documents, axis=0)
 return dataframe Retrieve detailed information about SAP BusinessObjects documents effortlessly using a single line of Python code. Utilize the function, and the resulting DataFrame provides a straightforward overview of document attributes. get_all_dataframe df_documents url = "http://{}:6405/biprws/raylight/v1/documents/".format(localhost)
df_documents = get_all_dataframe(url=url)
print(df_documents.head()) Showcasing df_documents: What follows is a glimpse into the dataframe structure document id cuid name folderId description 10283 AfZQen_U5hGgHqB8 Revenue Report 10782 NaN 12012 AUgbex_JocxFfvSFw Sales Report 11931 NaN 12435 AaGqyXfPrFIuC1Eac Cost Report 11965 NaN 11232 ATvl8iD_ii2HdxkKEY Inventory Report 11038 NaN 11023 cyslJAAy.JAJBB13hE Finance Report 11021 NaN Part 3: Document Details Extraction If you need additional details such as the document's path, last updated time, scheduling status, size, and refresh status, utilize the following function. This function fetches the specified details for each document in the DataFrame, providing a more comprehensive overview of each entry. df_documents def get_document_detail(documentID, detail):
 url = 'http://{}:6405/biprws/raylight/v1/documents/{}'.format(localhost, documentID)
 res = requests.get(url, headers={
 "Accept": "application/json",
 "Content-Type": "application/json",
 "X-SAP-LogonToken": logon_token
 }).json()
 return res['document'][detail]

def get_more_information_from_documents(df):
		details = ['path', 'updated', 'scheduled', 'size', 'refreshOnOpen']
		for detail in details:
 df[detail] = [get_document_detail(id, detail) for id in df['id'].values]
 return df

df_documents_more_info = get_more_information_from_documents(df_documents) Showcasing df_documents_more_info: document id cuid name folderId description path updated scheduled size refreshOnOpen 10283 AfZQen_U5hGgHqB8 Revenue Report 10782 NaN Public Folders/Test 2023-06-04T08:24:23.461Z false 64613 true 12012 AUgbex_JocxFfvSFw Sales Report 11931 NaN Public Folders/Test 2023-06-04T08:30:17.907Z false 64481 true 12435 AaGqyXfPrFIuC1Eac Cost Report 11965 NaN Public Folders/Test 2020-06-22T02:06:55.858Z false 65471 true 11232 ATvl8iD_ii2HdxkKEY Inventory Report 11038 NaN Public Folders/Test 2023-07-17T08:06:38.444Z false 171294 true 11023 cyslJAAy.JAJBB13hE Finance Report 11021 NaN Public Folders/Test/Test 2023-07-08T03:04:05.241Z false 168952 true Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn

Unlocking SAP BusinessObjects Data: The Full Guide to Retrieving Documents with Python

Recently, I faced a mission: organizing all SAP Business Objects schedules into an Excel file. The manual process was tedious—copying each schedule name and details and pasting them into Excel. With hundreds of schedules, it meant endless copy-pasting. I scoured the internet for solutions and found that the primary solution is Query Builder. However, exporting the Power Builder results from the web into an Excel file is still challenging. I also tried the SAP Business Objects API, it could fetch all schedules, but the number of recurring schedules is not the same as what we saw in SAP BO CMC. So, I turned to Python, and it works! If you're grappling with the same challenge, my code might be the solution you're seeking. I mporting Libraries import pandas as pd
from selenium import webdriver
from bs4 import BeautifulSoup
from selenium.webdriver.common.by import By
import time Here, it’s importing necessary libraries. for data manipulation, for web scraping, for HTML parsing, and for adding pauses between operations. pandas selenium BeautifulSoup time Setting up SAP BO Connection Details bo_cmc = 'http://localhost:port/BOE/CMC'
bo_user_name = 'username'
bo_password = 'password' It defines the SAP BusinessObjects Central Management Console (CMC) URL and login credentials. Function to Get Soup (HTML Content) def get_soup(driver, xpath):
    element = driver.find_element(By.XPATH, xpath)
    soup = BeautifulSoup(element.get_attribute("innerHTML"), 'lxml')
    soup.prettify()
    return soup This function uses Selenium to locate an HTML element using XPath, extracts its inner HTML, and then creates a BeautifulSoup object for parsing. Functions to Convert HTML to List and DataFrame def bo_instances_html_to_list(soup):
    n = int(len(soup.select('tr td div')) / 16)
    values = [[] * n for _ in range(n)]
    for i in range(n):
        for j in range(16):
            values[i].append(soup.select('tr td div')[i * 16 + j].text)
    return values

def bo_values_to_df(values):
    df = pd.DataFrame(values)
    df.columns = ['', 'title', 'type', 'status', 'location', 'owner', 'completion_time', 'next_run_time',
                  'submission_time',
                  'start_time', 'duration', 'recurrence', 'expiry', 'server', 'error', 'title2']
    return df

def bo_instance_to_df(soup):
    values = bo_instances_html_to_list(soup)
    df = bo_values_to_df(values)
    return df These functions convert HTML content of SAP BO instances into a list and then into a Pandas DataFrame. Selenium Automation Function def bo_selenium_to_df():
    options = webdriver.ChromeOptions()
    prefs = {'profile.default_content_settings.popups': 0}
    options.add_experimental_option('prefs', prefs)
    options.add_experimental_option("detach", True)
    driver = webdriver.Chrome(options=options)
    driver.get(bo_cmc)
    driver.switch_to.frame("servletBridgeIframe")
    time.sleep(3)

    username_input = driver.find_element(By.XPATH, '//*[@id="_id2:logon:USERNAME"]')
    password_input = driver.find_element(By.XPATH, '//*[@id="_id2:logon:PASSWORD"]')

    time.sleep(1)
    username_input.send_keys(bo_user_name)
    time.sleep(1)
    password_input.send_keys(bo_password)
    time.sleep(1)

    login_button = driver.find_element(By.XPATH, '//*[@id="_id2:logon:logonButton"]')
    time.sleep(1)
    login_button.click()

    time.sleep(5)
    html_text = driver.execute_script("return document.documentElement.outerHTML")
    contentFrame = driver.find_element(By.XPATH, '//*[@id="contentFrame"]')
    driver.switch_to.frame(contentFrame)
    time.sleep(2)

    innerContent = driver.find_element(By.XPATH, '//*[@id="innerContent"]')
    driver.switch_to.frame(innerContent)
    time.sleep(2)

    instance_manager_href = driver.find_element(By.XPATH, '//*[@id="manageList"]/li[1]/a[2]')
    instance_manager_href.click()
    time.sleep(1)

    # instancemanager
    ## switch to innerContent iframe
    html_page = driver.execute_script("return document.documentElement.outerHTML")
    contentFrame = driver.find_element(By.XPATH, '//*[@id="contentFrame"]')
    driver.switch_to.frame(contentFrame)
    time.sleep(1)

    innerContent = driver.find_element(By.XPATH, '//*[@id="innerContent"]')
    driver.switch_to.frame(innerContent)
    time.sleep(1)

    frames = []

    soup = get_soup(driver, xpath='//*[@id="UniversalRepositoryExplorer_detailView_mainTableBody"]')
    n = int(len(soup.select('tr td div')) / 16)
    df_start = bo_instance_to_df(soup=soup)
    frames.append(df_start)

    # In SAP BusinessObjects (SAP BO), schedules default to displaying 50 schedules per page.
    while n == 50:
        next_page_button = driver.find_element(By.XPATH, '//*[@id="UniversalRepositoryExplorer_goForwardButton"]')
        next_page_button.click()
        time.sleep(2)
        soup = get_soup(driver, xpath='//*[@id="UniversalRepositoryExplorer_detailView_mainTableBody"]')
        df = bo_instance_to_df(soup=soup)
        frames.append(df)
        n = int(len(soup.select('tr td div')) / 16)

    df = pd.concat(frames, axis=0)
    driver.close()
    drop_column = ['', 'completion_time', 'start_time', 'duration', 'server', 'error', 'title2']

    for column in drop_column:
        df = df.drop(column, axis=1)

    df['index'] = range(1, len(df) + 1)
    df = df[['index', 'title', 'type', 'status', 'location', 'owner', 'next_run_time',
             'submission_time', 'recurrence', 'expiry']]
    return df This function uses Selenium to automate the process of logging into SAP BO, navigating to the schedule manager, extracting schedule details, and finally converting them into a Pandas DataFrame. Executing the Selenium Function df = bo_selenium_to_df() This line calls the Selenium function and stores the resulting DataFrame in the variable . df Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn Also appears . here

Python Web Scraping in SAP Business Objects CMC: Getting the List of Schedules

To retrieve a list of SAP Business Objects schedules using Query Builder, you can execute a query against the repository database where the scheduling information is stored. The repository database typically contains tables with information about schedules, jobs, and other related objects. Here are the general steps: Access and Log in to Query Builder: To access Query Builder directly, log in to Query Builder using your SAP Business Objects credentials by entering the following URL in your web browser: :port/AdminTools/querybuilder/ie.jsp. http://localhost Build Query: SELECT 
    SI_ID, 
    SI_NAME, 
    SI_SCHEDULEINFO.SI_SCHEDULE_TYPE, 
    SI_SCHEDULEINFO.SI_SCHEDULE_INTERVAL_NDAYS, 
    SI_SCHEDULEINFO.SI_SCHEDULE_INTERVAL_NTHDAY, 
    SI_SCHEDULEINFO.SI_SCHEDULE_INTERVAL_MONTHS 
FROM 
    CI_INFOOBJECTS 
WHERE 
    SI_SCHEDULE_STATUS != 8 AND SI_RECURRING = 1 the script retrieves specific columns ( , , and scheduling-related information) from the table for objects that meet the specified conditions. The conditions filter out objects with a schedule status of 8 and include only recurring objects. SI_ID SI_NAME CI_INFOOBJECTS Execute Query: Copy and Paste the SQL Script, Then Submit the Query Review Results: After the query execution is complete, the results will be displayed in the Query Builder interface. Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn

How to Fetch a List of SAP BusinessObjects Schedules Using Query Builder

The SAP BusinessObjects RESTful Web Service (RESTful API) is an application programming interface provided by SAP BusinessObjects. It allows developers to interact with SAP BusinessObjects BI (Business Intelligence) platform functionalities through HTTP requests. This RESTful API enables the integration of SAP BusinessObjects services into custom applications, facilitating tasks such as retrieving, creating, updating, and deleting BI content, as well as managing user permissions and security. With the RESTful API, developers can perform operations like fetching information about reports, universes, folders, scheduling, and other BI-related entities. This approach promotes interoperability and simplifies the integration of SAP BusinessObjects BI capabilities into various applications and workflows. How to Fetch universes using Python? Part 1: Authentication To initiate the authentication process, please replace the placeholder values for , , and with your specific configuration details. username password localhost import requests
import pandas as pd
import xml.etree.ElementTree as ET

# define the login request parameters
user_name = 'username'
password = 'password'
localhost = 'localhost'

auth_type = 'secEnterprise'
login_url = 'http://{}:6405/biprws/logon/long'.format(localhost)
login_data = f'<attrs xmlns="http://www.sap.com/rws/bip"><attr name="userName" type="string">{user_name}</attr><attr name="password" type="string">{password}</attr><attr name="auth" type="string" possibilities="secEnterprise,secLDAP,secWinAD,secSAPR3">{auth_type}</attr></attrs>'
login_headers = {'Content-Type': 'application/xml'}

# send the login request and retrieve the response
login_response = requests.post(login_url, headers=login_headers, data=login_data)
# parse the XML response and retrieve the logonToken
root = ET.fromstring(login_response.text)
logon_token = root.find('.//{http://www.sap.com/rws/bip}attr[@name="logonToken"]').text
api_headers = {'Content-Type': 'application/xml', 'X-SAP-LogonToken': logon_token} Part 2: Data Retrieval and DataFrame Creation Previewing Retrieved Data: First Universe's Name This Python snippet fetches all the information about universes from the server. If you run the code, it will print the name of the first universe. response = requests.get("http://{}:6405/biprws/raylight/v1/universes/".format(localhost),
 headers=api_headers)
root = ET.fromstring(response.text)
print(root.findall('universe')[0][2].tag, ":", root.findall('universe')[0][2].text) Data Transformation Functions: Transform to DataFrame The Python functions, , and , work together to simplify SAP BusinessObjects data retrieval. The first function transforms XML data into a structured pandas DataFrame, capturing document attributes. The second function efficiently handles scenarios with universes exceeding a single request's limit by appending multiple DataFrames. Collectively, these functions streamline the conversion of XML to DataFrame and provide an easy solution for handling a large number of universes. get_dataframe_from_response get_all_dataframe def get_dataframe_from_response(response):
 # Parse the XML data
 root = ET.fromstring(response.text)
 # Extract the data into a list of dictionaries
 res = []
 for item in root.findall('universe'):
 doc_dict = {}
 for elem in item.iter():
 if elem.text is not None:
 doc_dict[elem.tag] = elem.text
 res.append(doc_dict)
 # Convert the list of dictionaries to a pandas dataframe
 df = pd.DataFrame(res)
 return df

def get_all_dataframe(url):
 documents = []
 for i in range(50):
 offset = i * 50
 url_offset = url + "?offset={}&limit=50".format(offset)
 response = requests.get(url_offset, headers=api_headers)
 df = get_dataframe_from_response(response=response)
 if df.empty:
 break
 else:
 documents.append(df)
 dataframe = pd.concat(documents, axis=0)
 return dataframe Retrieve detailed information about SAP BusinessObjects universes effortlessly using a single line of Python code. Utilize the function, and the resulting DataFrame provides a straightforward overview of universes attributes. get_all_dataframe df_universes df_universes = get_all_dataframe(url="http://{}:6405/biprws/sl/v1/universes".format(localhost)) Showcasing : What follows is a glimpse into the dataframe structure df_universes Part 3: Universe Details Extraction If you need additional details such as the universe's path and connected status, utilize the following function. This function fetches the specified details for each universe in the DataFrame, providing a more comprehensive overview of each entry. df_universes def get_universe_detail(universeID, detail):
 url = 'http://{}:6405/biprws/raylight/v1/universes/{}'.format(localhost, universeID)
 res = requests.get(url, headers={
 "Accept": "application/json",
 "Content-Type": "application/json",
 "X-SAP-LogonToken": logon_token
 }).json()
 return res['universe'][detail]

def get_more_information_from_universes(df):
 details = ['path', 'connected']
 for detail in details:
 df[detail] = [get_universe_detail(id, detail) for id in df['id'].values]
 return df

df_universes_more_info = get_more_information_from_universes(df_universes) Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn Also published . here

How to Fetch SAP Business Objects Universes Using Python

Microsoft Dynamics 365 Business Central is a comprehensive business management solution designed for small to medium-sized businesses. It automates and streamlines the business process by helping users to manage your business. If you’re seeking to have a comprehensive business management solution, then Dynamic 365 BC is for you. It’s simple to use and adapt business collaborations with allowing you to make smart decisions. The business application extended and utilized other Microsoft Cloud Services such as Office 365, Power BI, Microsoft Flow, and other Power Apps. Dynamic 365 BC adapts itself by changing business and growing business needs while taking benefits of advanced technology. Why choose Microsoft Dynamic 365 Business Central? Financial Management Supply Chain Management Operation Management Project Management Reporting and Analysis Sales and Service Management The Microsoft Dynamic 365 approach is: Customizability Flexibility Enhanced Security Dynamics 365 Vs NetSuite Let’s move on with the topic by understanding how is best over NetSuite. Microsoft Dynamic 365 Business Central In simple words, have you used a single phone line with multiple users? Yes, it was common during the early days of the telephone. Now, can you imagine your info is shared with other parties? Similarly, party-line works like NetSuite’s multi-tenant software, whereas Dynamic 365 works as a single-tenant solution. Things to note about Netsuite: It’s complicated and takes time to deploy with requiring extensive customization. The service contracts are inflexible, and the pricing adds thousands of dollars per year. It was acquired by Oracle in 2016 and suffer losses in the last few years Dynamics 365 Vs QuickBooks QuickBooks QuickBooks owned by Intuit and started in 1983. It’s one of the best payroll systems and credit card processing add-ons as it plays a big part in the QuickBooks solution. It comes with a full range of deployment options. One can run the solution page in a single-tenant configuration with QuickBooks. Compared with Dynamic 365, it has more critical advantages like easy payroll integration and payment processing. However, there are a few restrictions that QuickBooks offers. Things to note about QuickBooks: Weak security options and too easy for making mistakes with improper data access. Not Robust and no login records or change to master records possible. It comes with Limited reporting options, which makes it difficult for customer insights and analytical capabilities. It’s not scalable. Therefore, if you have a growing business, consider using Dynamic 365 BC to have better billing options. As with QuickBooks, it’s challenging to manage third-party or different client locations. How Dynamic is 365 Business Central better than QuickBooks? One of the biggest strengths is its value, as Microsoft claims that Business Central owns 800+ more features than QuickBooks. Moreover, Business Central has functionality that goes beyond scalability and reporting. Also, when comparing the pricing, then Microsoft Dynamic is quite cheaper than QuickBooks. Dynamic 365 is quite robust and has better protection against employee theft and errors. Microsoft Dynamic vs Tally Today with the emerging business market, Tally is an accounting tool. Tally is used to growing business and helps to switch to global ERP’s. Tally accounting works on 32 inbuilt groups, whereas Dynamic is based on a chart of accounts that varies from customer to customer. Tally does not have product posting group concepts, vendor posting groups, customer posting groups, inventory groups, etc. Simultaneously, Microsoft Dynamic has a clear vision and road map for its products like , Dynamic 365, Dynamics AX, and Business Central. Microsoft uses the cloud-based solution and comes with the great advantage of adding Microsoft products like outlook, skype, Microsoft office, dynamic CRM as their collaboration capabilities. Dynamic NAV Microsoft Dynamic vs SAP SAP Business is designed to keep small to mid-sized businesses in focus. As SAP offers an integrated system, it allows us to manage and coordinate customer relationships, sales, and business intelligence reporting with ease. Using SAP Business One, the user gets real-time information on the most critical business metrics. SAP is built and runs on Microsoft SQL Server. It gives vast benefits by helping employees to update data from anywhere. Things to note about SAP: It’s too complicated to use since SAP has traditionally associated with large-size Fortune 500 companies. It makes it difficult to troubleshoot, and error is not always clearly found. If you want to focus on small to medium size, then go with Microsoft Dynamic as SAP if more Fortune 500 companies. Microsoft Dynamic 365 offers several customized options and comes with more than 750 add-ons solutions on AppSource Market. One can integrate it effortlessly with hosting Microsoft business applications. It gives more access to its features and functionality while helping to increase overall accuracy and efficiency. Dynamic 365 is better for long-term fit organizations. As mentioned, Microsoft Dynamics 365 Business Central is a comprehensive business management solution designed for small to medium-sized businesses. It automates and streamlines the business process by helping users to manage your business.

Advantages of Microsoft Dynamics 365 business central over NetSuite, Tally, QuickBooks, and SAP

You’ve likely heard of Ethereum in the context of cryptocurrency, but perhaps not so much in the context of enterprise software. In this blog you will learn what and are. You will learn how easy it is to connect an SAP ABAP-based system to Ethereum mainnet, try out a demo, and see . Ethereum Ethereum mainnet all the related source code The Ethereum Network Firstly then, a whirlwind tour of Ethereum and its uses. Ethereum is some software you can run on a network of computers referred to as . Each node can be thought of as being identical to all the others. nodes Nodes can run simple programs called inside a virtual machine called the Ethereum Virtual Machine (EVM). These smart contracts have access to limited compute and storage resources. smart contracts Ethereum deals with that can be triggered by an external user or process, can run a smart contract program and change the state of data held on the Ethereum network. transactions Transactions can be posted every 15 seconds or so and are atomic, they either succeed or fail. If they fail then all changes they made are undone. Similar to SAP business process transactions, an Ethereum transaction is intended to perform some limited business logic and storage. Ethereum is not designed for compute-heavy, storage-heavy or very low-latency operations. You can think of the Ethereum network like this, many different nodes each with an EVM running inside them: Ethereum stores smart contracts and the data associated with them in a data structure called a , sometimes referred to as just a . New transactions get grouped into and validated by the nodes on the network. blockchain chain blocks all Transactions are then added to the end of the chain, together with a “fingerprint” (a hash) representing all the previous blocks. This fingerprint feature makes it intentionally very difficult to retrospectively adjust data. The idea is that once a transaction is posted it has been validated by every node and is permanent. So far so good, if a little unexciting. What interesting is that when this Ethereum software is run on a network of nodes, a special feature emerges. is The special feature is that even if individual nodes are operated by strangers that you cannot necessarily trust, the overall network itself be trusted to process transactions as the transaction originator intended. can This network is very resilient. The overall network can be trusted even if many node operators start colluding together to fiddle with data they are processing. This special feature can be referred to as “the trustless network”. There is no central authority, middle-man or 3rd party that must be trusted to check that the network is processing transactions honestly. The network of strangers “polices itself”. Ethereum is one example of Distributed Ledger Technology (DLT). The collection of transactions in blocks can be thought of as a ledger, and the network of nodes is the distributed part, hence it forms a DLT. There is much more to how Ethereum works. The above summary omits a lot of detail that is not relevant to this article. For example, Ethereum is closely associated with cryptocurrency but that aspect is not of interest here. If you want to read more, the book by Andreas Antonopolous is highly recommended. It is free and open-source. Mastering Ethereum Ethereum is young, it turned 5 years old in July 2020 and is an ongoing project. is underway which will, among other things, improve scalability. This article relates to the Ethereum 1.0 software that is available today. Ethereum 2.0 development Ethereum Mainnet As you’ve just learned, Ethereum is software that you can run on a bunch of networked computers. How big is a bunch? Well, you could run it on a private network inside your enterprise (a blockchain), or you could open it up a bit and allow known parties to have access and run nodes too, perhaps other enterprises you do business with. private When all the parties operating nodes are known, the network is called a blockchain. People can only join the network if they receive permission from those already running it. permissioned An advantage of permissioned chains is that the entire network, all its data and logic, can be hidden from those that are not part of it. This is particularly desirable when dealing with sensitive information. There are where permissioned blockchains might make a good choice. many use-cases Software like IBM’s Hyperledger Fabric, JP Morgan’s Quorum and can be used for these cases. SAP offer Blockchain-as-a-Service options for chains like these and have some on the use-cases. many others excellent documentation If you fast forward a few years you can imagine lots of permissioned chains with each organisation belonging to many. Therefore the potential long term downside of permissioned chains is that logic and data ends up in multiple, partially overlapping silos. Anyway, the focus of this article is not permissioned chains, rather it is the public, -permissioned Ethereum network that is of interest: the . un Ethereum mainnet It is public, because anyone, including you, can run a node in the mainnet. All you need is some commodity hardware, some and an internet connection. Ethereum software In fact something are operating on mainnet at any one time, each dutifully validating every transaction. This is worth emphasising: every node executes transactions. This is not distributed processing with the goal of increasing throughput. around 7,000 nodes the same This is distributed processing with the goal of ensuring the network can be trusted. It would require over half of these nodes to collude to start successfully tampering with data. This is the strength of such a large distributed system. You don’t need to run a node yourself to use mainnet. You can send transactions to any node you have rights to and the transaction will get processed. A popular option is to use an node, but bear in mind you’re then placing trust in Infura to operate their nodes fairly. Infura The mainnet can be thought of as some always-on cloud infrastructure that you don’t have to pay for up front. A small fee is incurred per transaction which gets paid to node operators, typically a few USD cents but for transactions that use more compute and storage this can run to several USD. The fee is paid in the network’s own internal currency called . Ether You can imagine mainnet as a global, single-instance computing environment, controlled by no central authority, where simple programs can execute and store small amounts of data without risk of interference or corruption. Take this idea further and imagine lots of enterprises connected to mainnet. You can imagine mainnet acting like a single, global, enterprise service bus. In this context, mainnet is sometimes called the “magic bus”. Demo Time Now you will see how easy it is to connect an ABAP-based system to mainnet. The demo scenario imagines using a smart contract on mainnet that matches buyers and sellers of raw materials. Imagine a SAP ECC system needs to procure some cobalt for manufacturing processes. An ABAP program sends a buy offer to a web service saying you would like to buy 1000 kilos of cobalt for 30 USD per kilo. Sellers of cobalt could post similar sell-side transactions to the smart contract saying they want to sell cobalt for a specified price. When a match is made, the buyer and seller can obtain details of their counterparty, and the rest of the business process can happen as usual. Doing this in smart contracts on mainnet means that no central party needs to be in control of the process, and no central party needs to have the power to shut the smart contract down. The smart contracts can be deployed and left to run autonomously. This differs from a centralised web portal-based solution, where some organisation builds and runs the marketplace and can shut it down whenever it wants. In practice, of course some ability to upgrade smart contract code and fix bugs is desirable. There are decentralised governance options to manage this which are beyond the scope of this article. The point remains that no single party needs to be in control. The components shown in the above diagram are as follows: SAP ECC Program This simple report acts as the UI for the process. The report title you choose will act as the unique identifier for your system in the smart contract, you will see this shortly when running the demo. ABAP This report does not know anything about Ethereum or smart contracts, it just interacts with a web API. copy the from into a new ABAP report and activate it. To install: report source code the main GitHub repo Web API This simple API allows you to create new buy offers and list existing buy offers and see their status. The API is written using and so is very portable, it is trivial to install it on Linux or Windows servers. .NET Core The source code is available in , see project SapEthereumIntegration.Api.csproj under solution SapEthereumIntegration.sln. There is for experimenting with the API. the main GitHub repo a Postman collection Internally the API connects to an Infura node using the excellent (which ). The API knows all the configuration necessary to connect to Ethereum, the details of the smart contract to call and some test Ether to pay the fees for new transactions posted. Nethereum library has a very friendly team This API is already installed on Azure and is freely usable without installing anything. To see it working, put into your browser to see a list of all current buy offers. To install: https://sapethapiver01.azurewebsites.net/api/market Smart Contract The smart contract is written in , a scripting language for writing the business logic and storage parts of our process. The contract accepts new buy offers, validates them, and matches them with a seller. Solidity For the purposes of the demo, all offers are instantly matched with a seller. There is a popular Ethereum data browser called that allows you to examine contracts and transactions. The as well as . Etherscan contract source code is visible on Etherscan in the main GitHub repo The contract is already installed on a mainnet-like test Ethereum network called Rinkeby and is usable without installing anything. To install: Demo Execution Run the ABAP you installed earlier and on the Display Offers tab, click the Display Offers button: The list of current buy offers is shown, retrieved from smart contract storage. The System Id shown above comes from your ABAP report description, and is intended to be a unique-ish identifier for your data held in the smart contract. Tick the checkbox “Show All System Ids” to see buy orders for every user of the smart contract. Now you can create a new buy offer. Click the “Create Buy Offer” tab: Enter a raw material free text, a quantity in kilos and a price. Press “Create Buy Offer” and a new transaction is sent to the smart contract. After 10 to 15 seconds whilst the Ethereum network processes this new transaction, you should see a message at the bottom saying “Buy Offer created”. If you return to the “Display Offers” tab and refresh, you will see your new order has been placed, and matched with the seller with email cob@lt. , albeit the information it shows is a bit cryptic. Congratulations, you’ve just interacted with the Ethereum mainnet from ABAP. Easy peasy! Ethercan will also show the new transaction Before you implement anything productive relating to mainnet, you need to understand the final section: privacy. Mainnet Use-Cases and Privacy Mainnet has lots of potential overlap with the , but without the side effect of generating silos. The limitation of mainnet in this context is privacy. permissioned chain use-cases Mainnet is public by design. All the smart contract code is public. All the related data it stores is public. All transactions are public. You get the idea, and this doesn’t often suit enterprises. In the demo example above, you likely don’t want anyone to know what deal you got on cobalt. Encryption is an option. If you trust your encryption enough to make the encrypted data public to the internet forever then this might be viable. This may suit some use cases, but it is clearly not perfect. Another option is to sensitive information on mainnet at all. Instead it is possible to store that sensitive information is known, and not the sensitive information itself. not store evidence Whilst this may sound like Gandalf the Wizard has started running IT projects, it is possible using technology called Zero Knowledge Proofs (ZKP). The is that, if I know a secret, I can convince someone else that I know the secret, without revealing about the secret itself. principle behind ZKPs anything at all There is an open source project that seeks to allow enterprises to collaborate over mainnet without revealing sensitive information. It is called the . Baseline Protocol Founding members include Microsoft, AMD and Ernst & Young (who are behind the also working with ZKP). The baseline protocol is a specification and an open source reference implementation. The project . Nightfall project community is friendly Conclusion You’ve seen how easy it is to connect to Ethereum mainnet, and should have a better idea of what it is. This example used .NET Core as the middle layer between SAP and Ethereum, but many languages could be used. For example, to connect to Ethereum from a SAPUI5-based UI, you could use the library. web3.js To continue learning about Ethereum and mainnet, has a dedicated section on . Ethereum.org enterprise usage Previously published at https://blogs.sap.com/2020/08/21/sap-integration-with-ethereum-mainnet/

SAP

sap.com

-- employees

Since n.d.

COMPANY RANKING

SAP

EVERGREEN INDEX #9487

Representing this company? Click here to claim and customize this page!

SAP WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

SAP