My ABAP life

Blag's best blogs picks from 2009

2009-12-12T06:51:00.001-08:00

Blag's best blogs picks from 2009
Alvaro Tejada Galindo
Business Card
Company: Biz Partner
Posted on Dec. 11, 2009 12:12 PM in ABAP, Perl, PHP, Python, Ranting, Ruby, SAP Developer Network, SAP NetWeaver Platform, SAP TechEd, Scripting Languages, Standards, Virtual Worlds and 3D Web, Visual Composer, Web Dynpro, Open Source, Mobile, Java Programming, Application Server, Beginner, Beyond SAP, Business Intelligence (BI), Business Objects, Business Process Expert, Business Server Pages, Code Exchange, Community Day, Community Projects, Composition Environment (CE), Emerging Technologies, Enterprise Portal (EP), Widgets

	Subscribe
	Print
	Permalink

First...please keep in mind that choosing the best from the whole 2009 year was a very consuming and hard job...so if I pass any great blog, please bear with me -:)

ABAP:

Another way to create Excel output - Michael Nicholls

ABAP Join Wizard is here! - Leonardo De Araujo

Basic ABAP OO eLearnings - Thomas Jung

Ranting:

Don't tell me I am OBSOLETE - it hurts! - Vijay Vijayasankar

Tale of an SAP addict... - Alvaro Tejada Galindo

Just a developer?! - Michelle Crapo

Don't You Step On My... - Jim Spath

The Fine Art of Balance - Graham Robinson

WebDynpro:

A story about Twitter, XML and WD4A - Uwe Fetzer

SAP Flash Island and Google Maps - Mogens Enevoldsen

Navigating in Web Dynpro in a smart way - Stefan Bungert

Wave, Web Dynpro, and the Magic Glue: Google Wave and Web Dynpro Integration Part 1 - Thorsten Franz

Make phone calls from SAP applications with Flash Islands and Ribbit - Mrinal Wadhwa

Community Day:

SAP Inside Track London 2009 - Nigel James

The Community Day Brazil 2009 in a nutshell - Marcelo Ramos

SAP Inside Track Lima 2009 - The Recap - Alvaro Tejada Galindo

SAP Inside Track Sao Paulo - An amazing experience!! - Leonardo De Araujo

SAPInsideTrack London: My notes - Somnath Manna

Composition Environment:

ABAPers, Should You Jump the CE train? - Thorsten Franz

SOAP with Attachments made easy with CE - Werner Steyn

Using Amazon EC2 for testing CE Trial Part 1 - Daniel Graversen

an ABAPer's journey to Netweaver CE - Michael Koch

Ruby:

Tasting the mix of Blue Ruby - Alvaro Tejada Galindo

How to build a SE16 Emulator in Blue Ruby - Juergen Schmerder

Beyond SAP:

Agile SAP: Mission Impossible? - tbroek

Twitter + SAP Community + TechEd + Folks to Follow - Mark Yolton

SAP Mentor Monday: Anne Katherine Petterøe stopped Facebook TOS change - Mark Finnern

Ada Lovelace Day and the SAP Community Network - Marilyn Pratt

Think like an SAP Mentor: 3 Exercises how to become an SAP Top Technical Specialist in 7 Days - Tobias Trapp

Yowie surfing the Wave - Dr. Marek Kowalkiewicz

Standards:

Nomen est Omen - ABAP Naming Conventions - Uwe Schieferstein

Official ABAP Programming Guidelines - Horst Keller

SAP TechEd:

SAP TechEd Phoenix 2009 - My blogging review - Alvaro Tejada Galindo

Closing the Loop for BPXSlam09 Phoenix - Greg Chase

#sapteched09 Phoenix - my personal highlights selection - Juergen Schmerder

My #sapteched09 in Phoenix - Daniel Graversen

Comparing Teched 09 in Phoenix with Vienna - Daniel Graversen

The BPX Process Design Slam 2009 - tbroek

Application Server:

Indexes lose weight, but is that the answer? - Jim Spath

Cloud Computing at SAP - Frank Stienhans

REST-orientation: Controlling access to resources - DJ Adams

Python:

Python and SAP Adventures - David Hull

Beginner:

A Freshers Guide to ABAP and SDN - kartik tarla

Blogging in the SAP Community Network 101 - Natascha Schuberth

Getting Started on Twitter - Chip Rodgers

Business Process Expert:

Why twitter is not (yet?) all that valuable for BPXers ( and others) - Marco ten Vaanholt

So What Does it Take to Become an SAP Business Process Expert? - Jon Reed

BPM in Ten Years? My Best Shot - Thorsten Franz

Sustainability:

An hour a month, an hour a week, etc. - Jim Spath

Sustainability @ SAP - Peter Graf

Green the Hard Way - Christine Puccio

SAP Developer Network:

Assemble Your Tribe - Community Building in the 21st Century - Mark Finnern

Stop Thief - It's #blogtheft! - Thorsten Franz

SAP Mentor Highlights 2008 - Mark Finnern

SAP Community Bio: Your Connection Between SCN and LinkedIn - Scott Lawley

Enterprise Service Community:

SAP Enterprise Service and Google Wave - Daniel Graversen

Emerging Technologies:

Composition in the Cloud: Run your own SAP NetWeaver CE 7.1 EHP 1 in the cloud (Part 1 of 3) - Thorsten Franz

Introducing SAP Suggest - Sergio Cipolla

Agile Is A Journey - Michael Koch

Business Intelligence:

SAP BW Indexing Scheme (ORACLE) - Debanshu Mukherjee

Xcelsius and SAP BI - How to pass variable value using Web Service Connection - Anil Bavaraju

Business Objects:

Get a peek at the hottest product at SAP BusinessObjects - Robert Horne

Maps in Business Objects Polestar - Oliver Mainka

Service-Oriented Architecture:

The Future of SOA - Vishal Sikka

8 SOA mistakes architects should avoid - Bernhard Escherich

Gravity – Collaborative Business Process Modelling within Google Wave - Alexander Dreiling

Virtual Worlds and 3D Web:

SAP Education Virtual Learning Symposium 2009 - My thoughts - Alvaro Tejada Galindo

Business Server Pages:

Ajax in BSP - Shashank Kapoor

Parameter handling with a HTMLB Link - Denis Schrodt

Community Projects:

Rate this! - Maya Bahar

SDN Homepage for Mobile Devices (Beta) - Jason Lax

SCNotties - Craig Cmehil

We are open for OpenID! - Maya Bahar

Enterprise Portal:

Using YubiKey OTP to secure your Portal - Simon Kemp

Tool to simplify PCD object creation - Michael Nicholls

Java Programming:

Using Apache XSL:FO with WebDynpro to generate PDF Documents - Santosh Raghavan

And what's the direction with Java NOW? - Benny Schaich-Lebek

Do-it-yourself ALV: Customizable tables in Web Dynpro for Java - Dimitri Lubenski

Freedom for Java - Vishal Sikka

Mobile:

Online Purchase request (PR) Approval Application Using Blackberry - Sunil Manjunath

SAP CRM on iPhone with “Ajax weaver” - Pakdi Decnud

SAP Mentors : Now on your Windows Mobile - Abesh Bhattacharjee

Open Source:

Why Solaris for SAP? - Christine Puccio

Making Web Dynpro Open Source? What features of Open Source? - Puru Govind

Scripting Languages:

SAP PI XML Mappings using groovy - Daniel Graversen

Visual Composer:

Flash Components for Visual Composer 7.0 - Flexibility is the name of the game - Amir Mimran

Widgets:

Bring the Business Suite to your Desktop -- Try XBCML Widgets Today - Moya Watson

Code Exchange:

New developer licenses for NetWeaver on the horizon - Mario Herger

Careers:

What is your title? - Vijay Vijayasankar

The importance of being trained... - Julius Bussche

Alvaro Tejada Galindo is an Project Manager, Senior ABAP Consultant, Scripting Languages Geek, Programming books author, Geek Comics author and SAP Mentor.

Blag's best blogs picks from 2008

2009-12-12T06:50:00.002-08:00

Blag's best blogs picks from 2008
Alvaro Tejada Galindo
Business Card
Company: Biz Partner
Posted on Dec. 16, 2008 02:41 PM in ABAP, Open Source, PHP, Ranting, Ruby, SAP Developer Network, SAP NetWeaver Platform, SAP TechEd, Scripting Languages, Virtual Worlds and 3D Web, Visual Composer, Web Dynpro, Mobile, Java Programming, Application Server, Beginner, Beyond SAP, Business Intelligence (BI), Business Process Expert, Business Server Pages, Community Day, Community Projects, Composition Environment (CE), Emerging Technologies, Enterprise Portal (EP), Widgets

	Subscribe
	Print
	Permalink

Just like last year Blag's best blogs picks from 2007, this year I want to put the list of my favorite blogs of 2008.

To my hapiness, this years list is amazinly big...A lot of nice blog had been writen, so I want to say "Congratulations SCN...Great year!" -:)

ABAP

SDN Blog Browser by Alvaro "Blag" Tejada Galindo

ABAP Interpreter / Translator to Java – Open Source ABAP Parser by Felix Jeyareuben

Web Dynpro: Running Web Dynpro Applications over SAPGUI by David Fernandes Pietroniro

A Tool to Compare Runtime Measurements: Z_SE30_COMPARE by Siegfried Boes

ABAP Objects Wiki pages +10k Page Visits by Marcelo Ramos

Power of ABAP Objects: Overcome the Restrictions of SALV Model by Naimesh Patel

WebDynpro

Web Dynpro ABAP exercises from TechEd 2007 by Manfred Lutz

Web Dynpro ABAP: How Fast Can You Consume 1 Million Rows? by Thomas Jung

Practical tips for developing with ABAP WebDynpro by Roger Sainsbury

Using Flex in SAP Web applications (without Adobe Flash Islands) by Guillaume Garcia

Mobile

Mobile Webdynpro(Accessing Webdynpro Applications in Mobile Devices) by Sathishkumar GS

First steps with NW Mobile 7.1 Trial Version by Jan Fetzer

Native integration of SAP CRM on BlackBerry Devices by Gregor Wolf

Mobile Influence update - sneak peak of Ajax app by Jim Spath

Business Server Pages

ABAP Freak Show - jQuery for BSP by Thomas Jung

CHAT Application using BSP and AJAX by Salil Patel

Display Hierarchy Report in BSP using TableView and Tableview Iterator by Vijay Babu Dudla

Emerging Technologies

Twitter and the Enterprise by Craig Cmehil

SAP, ANDROIDS and HEALTHCARE by Paolo Romano

SAP NetWeaver Platform

Subscription program - From naysayer to yea-sayer by Harald Reiter

Poor performance: detective story for this week by Jim Spath

[Oracle] Index key compression by Stefan Koehler

Downtime Manager by Sapna Subramaniam

PHP

PHP Connector? A New Hope by Nigel James

Ruby

Blag's Flex 3 Compiler by Alvaro "Blag" Tejada Galindo

Scripting Languages

Singleton Classes in Actionscript 3.0 by Abesh Bhattacharjee

Virtual Worlds and 3D Web

BPX in Action Cartoon available by Richard Hirsch

Community Clubhouse on SmallWorlds by Alvaro "Blag" Tejada Galindo

New Approaches to Virtual Worlds by Alexander Bachmann

Second Life and SAP Public Sector by Alexander Bachmann

Application Server

SAPmvc, a new MVC for Classical ABAP Dynpro by Marcelo Ramos

Yes, you should floss your indices regularly by Jim Spath

Beginner

Little tool for performance by Alvaro "Blag" Tejada Galindo

How to use Workflow wizards? by Sunil Ojha

Beginning Blogging & the WYSIWYG Editor by Gali Kling Schneider

Building a Wiki and your reputation by Mario Herger

Beyond SAP

Marbles Game in ABAP by Naimesh Patel

Show us what you can do, Create your own open source project and share with SDN! by Marcelo Ramos

From The Grumpy Old Man: SAP employees confuse SCN with Twitter by Eddy De Clercq

BI BI Baby, BI BI by Eddy De Clercq

Easy search on SAP sites with Ubiquity by Daniel Graversen

Why Social Networks Matter Now by Mark Yolton

Business Intelligence (BI)

One stage stop to know all about BW Extractors-Part1 by swapna gollakota

BI Process Chains with Dynamic System Command by Ryan Quackenboss

Widgets

SAP TechEd 2008 Countdown by Marcelo Ramos

Working with SAP Widget Development Tools by Sumangala Byali

Actionscript Libraries for SAP Widget Foundation : Available now ! by Abesh Bhattacharjee

Community Day

Community Day Lima 2008 - The Recap by Alvaro "Blag" Tejada Galindo

SDN Community Day Mentor Hands-On Workshop by Thomas Jung

Nanomonk - Adobe and SAP by Craig Cmehil

Community Day Buenos Aires, el día después. by Ignacio Hernández

SDN community day in London - my experiences by Harald Reiter

SAP Community Day London 2008 by Darren Hague

Community Day Magic by Mark Finnern

Community Day Changed My Life by Darren Hague

Community Projects

The ESME Collaboration and what it tells us about Web 2.0 by Richard Hirsch

ESME - The Demo by Abesh Bhattacharjee

GuidEd - TechEd Information Aggregator for the iPhone by Oliver Kohl

Java Programming

An introduction to Scala, part 1 by Darren Hague

Isn't it Groovy - extending the Development Component build with Groovy? by Marion Schlotte

SAP Developer Network

Eddy was here... by Abesh Bhattacharjee

Signal versus Noise by Mark Finnern

What’s thy color? – v2.0 by Wenceslaus Gnana

SDN - long time ago by Santosh V

Business Process Expert

Some of the BPX Stars Have Aligned by Marilyn Pratt

Getting the Most Out of the BPX Community by Marco ten Vaanholt

The reputation problem by Dennis Howlett

The Geek Gap: Do Suits Care? by Bill Pfleging and Minda Zetlin

The BPX Community Book Finally here !...BPX Education and Certification #2 by Marco ten Vaanholt

SAP TechEd

Video: Behind the Scenes at SAP TechEd '07 by Chip Rodgers

SAP Forum in Brazil: Sao Paolo Hosted ~5000 including SDN Top Contributors by Mark Yolton

The people of SAP TechEd 2005-2007 by Craig Cmehil

SAP TechED Countdown Widgets Redux ! by Abesh Bhattacharjee

Social Networking - Beta Release by Craig Cmehil

Ranting

How to Lower Your Status in The SAP Community by Marilyn Pratt

How to Further Damage Your SAP Community Reputation by Marilyn Pratt

Why Do Companies Release Software with Bugs? by Bill Pfleging and Minda Zetlin

Composition Environment (CE)

Music Composition Environment by Ignacio Hernández

Enterprise Portal (EP)

Creating Search Webpage Process in CAF-GP by rakesh verma

Visual Composer

Visual Composer demo - Customer and Google API by Jakob Diness

How to create Portal content with the Visual Composer for Composition Environment? by Dafna Yanay

Visual Composer7.1 and Yahoo Maps - Part I by Vivek Kumar Mishra

Open Source

SAPmvc Framework Release 0.1.0 by Marcelo Ramos

Enjoy! -:D

Alvaro Tejada Galindo is an Project Manager, Senior ABAP Consultant, Scripting Languages Geek, Programming books author, Geek Comics author and SAP Mentor.

2009-12-12T06:50:00.001-08:00

Blag's best blogs picks from 2007
Alvaro Tejada Galindo
Business Card
Company: Biz Partner
Posted on Dec. 17, 2007 10:48 AM in ABAP, PHP, Python, Ruby, SAP Developer Network, SAP NetWeaver Platform, SAP TechEd, Scripting Languages, Web Dynpro, Perl, JavaScript, Java Programming, Application Server, Beginner, Beyond SAP, Business Intelligence (BI), Business Process Expert, Business Server Pages, Community Day, Emerging Technologies, Widgets

	Subscribe
	Print
	Permalink

This year is endind...We're soon going to start 2008 with a lot of nice news and surprises. I wanted to end this wonderful year with my humble list of best blogs...Not all categories are included, because I'm not an expert in every area...But I think it's still a nice list.

ABAP

SAPChess by Marcelo Ramos

ABAP Bitmap Image Processing Class by Thomas Jung

Tool for ABAP Developers: Easy ABAP Open SQL Joins! by Dushyant Shetty

WebDynpro

Yet another webdynpro (ABAP) se16 clone by Marcello Urbani

SAP Elegant Finder was born - it is the Open Source that makes a pleasure to search on Web Dynpro for ABAP by Sergio Ferrari

Integrating ALV in the Web Dynpro for ABAP(WDA ) application by Kamal Kumar

Business Server Pages

An Introduction to FLOB (Flex on BSP) by Thomas Jung

Not a how to, but a what is: MVC – Model View Controller Pattern by Benjamin J Deaver

Using YouTube API inside a BSP application by Ignacio Hernández

Emerging Technologies

SAP MP3 - plug Business and play Music by Sergio Ferrari

Engaging User Interfaces with Adobe Flex by Matthias Zeller

SAP NetWeaver Platform

Developer's Journey through the SDN Subscription Program - Ch.1 Getting the Goods by Ed Herrmann

Ruby

Tasting the mix of Ruby and SAP - Volume 4 by Alvaro Tejada Galindo

PHP

Tasting the mix of PHP and SAP - Volume 12 by Alvaro Tejada Galindo

PHP in Netweaver Platform by Abdulbasit Gulsen

Developing composite applications with PHP - Google Maps by Frederic-Pascal Ahring

JavaScript

BSP Meet your AJAX Framework: AJS by Daniel McWeeney

Python

sapnwrfc for Python - To complete a hat trick by Piers Harding

Scripting Languages

SAP NW RFCSDK - it's here! by Piers Harding

Application Server

Purely Offline Adobe Scenario for BAPI call by Lisha Peter

Wii Goes Enterprise by Ed Herrmann

Beginner

The ABAP Runtime Trace (SE30) - Quick and Easy by Siegfried Boes

SCRIPT DEBUGGING by Sudheer Junnuthula

Beyond SAP
majority desk - get your wiihands on! by Ed Herrmann
Psychopathology of Software Development by Tobias Trapp
Colgate-Palmolive & SAP Imagineering Fellowship by Daniel McWeeney

Business Intelligence (BI)
What should be the Next Big Thing for SAP in BW/BI? by Vitaliy Rudnytskiy

Business Process Expert
Gliffy Plug-in for SDN/BPX WIKI has finally arrived by Richard Hirsch

Widgets
SDN Contributor Wordpress Widget by Oliver Kohl
Create your First Yahoo! Widget! by Abesh Bhattacharjee
SDN Points on Your Desktop by Guillaume García

Community Day

SAP Mentor Program by Mark Finnern

SAP Community Day - Looking forward not backward... by Thomas Alexander Ritter

Where is Eddy? by Mark Finnern

Blag on TechEd (Las Vegas) - Community Day by Alvaro Tejada Galindo

Java Programming

Make a JavaFX application calling a BAPI, using your SAP NetWeaver 7.1 Composition Environment by Ignacio Hernández

SAP Developer Network

Forget the 1 Million... by Craig Cmehil

Two Shots from the Past by Mark Finnern

SAP Community Network Reaches One Million Members! by Mark Yolton

SAP TechEd

My TechEd 2007 experience....a photo tour! by Christopher Solomon

Majority...what? Majority Desk! by Alvaro Tejada Galindo

Happy Blogging!

Alvaro Tejada Galindo is an Project Manager, Senior ABAP Consultant, Scripting Languages Geek, Programming books author, Geek Comics author and SAP Mentor.

Ten golden rules that help me every day

2009-09-21T22:53:00.001-07:00

Ivan Femia

In this short blog I would give you some tips and tricks that could make your SAP life easier and, even more, generate a money saving.

Good programmers write good code, but great programmers reuse the good programmers’ code! Do not create something that is already done, try to find a standard function already created by SAP or try to understand what the standard do in order to optimize your development.
Perform always the extended check (SLIN), this makes your development conform to SAP standards line guides and simplify code adjustments (e.g. after a system upgrade).
Try to follow a well defined naming convention, this SDN blog could be a good start example Nomen est Omen – ABAP Naming Conventions.
Monitor your reports with standards tool in order to optimize your code and find bottle necks (e.g. ST05 and SE30).
Have a problem in a standard report, check SAP OSS your issue probably is already solved by SAP.
Avoid standard modification take a look to the new Enhancement Framework.
Even if you are or not an expert take part to the SCN community: forum, blog and wiki; you will learn something new.
SAP is not only ABAP, there are a lot of technologies related: Web Dynpro, Java, RIA and so on, find the right one for your project. All of them have its pros and cons.
Consider web services and ABAP proxy as system integrator, base your developments onto these powerful technologies, instead of out of date flat files and other stuffs.
Finally share your knowledge on SCN, all of us are ready to learn.

Any suggestion is always appreciated

I wanna thank Andrea Olivieri for his support.

Troubleshooting Your ABAP Programs Using Coverage Analyzer

2009-09-08T07:04:00.001-07:00

Zahack
Business Card
Company: YASH Technologies
Posted on Aug. 31, 2009 12:28 AM in ABAP

	Subscribe
	Print
	Permalink

Coverage Analyzer is a very powerful runtime analysis tool provided by SAP that enables an ABAP developer to monitor processing blocks such as reports, subroutines, function-modules and methods.

Powerful filtering system in Coverage Analyzer facilitates developer to enter the number of calls separately according to periods, users and functional areas.

In a nut-shell; Coverage Analyzer is a function for persistently monitoring the system-wide execution of ABAP programs;

It enables the success of test activities to be assessed for quality checks.

It also provides an overview of the use of programs for development purposes.

Developer can use this tool to trace programs for development purpose and Quality Manager can use this tool to check system performance for quality assurance.

It helps carry out a range of Administration Settings and the Monitoring Activity. Moreover it helps get summarized information of number of program executions, number of runtime errors, number of program resets. Fascinatingly, the results can be formatted separately according to user-group; each user-group can contain any number of users under one test key.

Broadly, functions of Coverage Analyzer are classified into two;

1. Administration Settings

On/Off.
Test Groups.
Registrations.
Reset.
Settings.
Monitor.
Consistency Checks.

2. Display

Global.
Detail.

A simple exercise will help us easily understand Coverage Analyzer.

In order to make use of Coverage Analyzer, user has to have an appropriate role. To check user authorization;

Call up transaction SUIM (User Information System).

Expand Authorizations node.

Choose By Object and execute it (press F8).

Check the presence of authorization object S_COV_ADM in the system.

Confirm the where-used list for profiles using icon or Ctrl+Shift+F11.

Once user authorization is checked to have absolute access to SCOV (Coverage Analyzer) transaction; user can proceed further. If a role is not assigned to a user, Basis consultant has to be consulted in this regards.

In fact, a tip to be remembered is that Coverage Analyzer tool should be used on weekends or in the evening, when all users and packages are on loose ends. Since backup server collects data from all the servers including local and remote; system needs all packages and users to be in the passive mode.

Let's start up with a simple example to understand Coverage Analyzer in a better way:

Call up the transaction SCOV or navigate through SAP Easy Access->SAP Menu->Tools->ABAP Workbench->Test->SCOV (Coverage Analyzer).

General Status of the system is shown on the right hand pane of the window;

Coverage Analyzer administration includes all of the functions required for carrying out settings and checks.

Administration and Display nodes are shown on the left pane of the window.

Before the Coverage Analyzer being switched on, settings have to be maintained for backup server and filters are to be set. Having not made settings for backup server, if Coverage Analyzer is started, it simply throws out an information message to maintain background server for data collection.

So, Administration settings are to be done before starting up the Coverage Analyzer.

Expand Administration node, select Settings;

Settings function is used to set the parameters for the Global and Detail views, and to filter the programs to be checked via the package.

In order to make settings, switch settings to Change Mode (Cntrl+F1).

Tip to remember: A program is regarded as tested if the following conditions are fulfilled;

Count1 Absolute Value > 0.

Count2 Absolute Value > 0.

RABAX2 Absolute Value = 0.

Unicode Check = 1.

Count1 and RABAX1 indicate the number of programs executed and runtime errors since the Coverage Analyzer was started.

Count2 and RABAX2 indicate the number of programs executed and runtime errors since the last reset.

Further, assign package to be used during analysis. When a package is pre-selected, the evaluation for the Global view is only performed for this package. If this restriction is not applied, all of the programs are included together with those from local packages ($*) and programs generated locally without packages ( ).

If ABAP programs with a set Unicode flag are only to be traced by the Coverage Analyzer, then select Unicode checkbox. Checking Unicode is to mark it as ‘X', else leave it unattended.

It's optional to set the lights; lights provide a visual means of representing the status of the results for the degree of coverage in the Global and Detail views.

Lights are set by default, which can be set according to developer's way of analysis.

RED 0 LT 33 %

YELLOW 33 LT 66 %

GREEN 66 LE 100%

Further, Monitor Settings have to be done, which includes setting Trace Level and Maximum Entries Log and Maximum Entries Data Monitor.

There are 4 different trace levels (1-4), the higher the trace level, the more information is drawn for debugging.

Tip: The values for Maximum Entries Log and Maximum Entries Data Monitor limit the lines displayed for the General Log and Monitor Data Volumes in the monitor function.

The defaulted lines for log file are 100 and for data volume are 200.

Background server has to be specified, where precisely data is to be collected. Moreover, the period for which background job has to be repeated is also to be specified.

The defaulted value for Data Collection: Period (Min) is 30 mins, which can be modified based on developer's way of analysis. In this case, current server is specified as Background server.

Further, Summarization function facilitates checking the same processing blocks in several systems simultaneously.

Tip to remember: The results from the individual systems are local and those from the remote systems are summarized.

Local Degree of coverage LE 100%.

Summarized degree of coverage LE 100%.

Local Degree of coverage GE Summarized degree of coverage.

To determine RFC connection with current server, call up transaction SM59->RFC Destinations->R/3 Connections->E6SCLNT900.

Desired RFC connections in Summarize coverage results can be specified; moreover period and start time for summarize data can also be specified.

Finally, save the Settings.

Choose On/Off, Status in the Administration node and start up the Coverage Analyzer.

Switch Coverage Analyzer On/Off: This displays the number of programs that have been initialized.

Switch Automatic Recordings On/Off: This displays the automatic recording period and the version number for the Global view.

Switch Data Aggregations from Different Remote Systems: This displays background server and all of the other systems whose results are used for Data-aggregation.

If the server is in switched-off mode exception shows RED signal, GREEN signifies server to be in switched-on mode and YELLOW represents either RFC problem or database and shared memory inconsistency.

In this case, we'll proceed without switching on Switch Automatic Recording On/Off.

The servers which are actually running are shown as flagged up.

Create Test-Groups; Test-Groups are made to summarize and display the results of the Coverage Analyzer for a particular set of users under one generic key/heading.

Tip to remember: Test-groups should not be created more than 10. Moreover, only users assigned a role with the authorization object S_COV_ADM are allowed to define group.

Two pre-defined Test-groups are always available;

ALL - Coverage results summarized for all test groups on the local system.

COND - Coverage results on the local system as well as remote system.

In this case, we create a test-group.

To create a test-group; switch on the Change Mode, click Append Row icon provided in the application tool-bar.

Define a Test-group following Y/Z naming convention; then save it.

Next step is to assign users to the just-made test-group.

To assign Users to a test-group; switch on the Change Mode, click Append Row icon provided in the application tool-bar.

Select desired test-group for which users have to be assigned; in this case we assign SAPDEV02 as user to test-group ZTST.

Tip: A test-group can contain any number of users, for example, all HR developers in one group. That makes filtering pretty easy. Moreover, comparison of performance of test-groups can be done in Global view.

An optional function to be done is Reset; explicitly this function is intended for situations in which the results of the previous analyses are no longer required. It resets all the counters of the Coverage Analyzer to 0 for all the programs of a selected group.

Further more, implicit reset is carried out automatically as soon as the flow or the data of a program changes.

After successful reset, an information message is popped-up;

Consistency check has to be done for all the servers including remote ones, before proceeding to actual analysis;

Check Status of All Servers checks whether the status in the shared memory matches the status in the database.

Check Status of Background Jobs checks whether all the batch jobs of the Coverage Analyzer are activated. If this is not the case, the batch jobs are all rescheduled by means of the Repair function.

Check Table Consistency (Long Runtime) may become inconsistent if the Coverage Analyzer fails on an application server due to system error.

Repair function also bridges the gap between activating and generating a program.

So, in order to check inconsistencies, check the types of inconsistencies accordingly and Execute Checks, and then choose monitor to check for the inconsistency messages,

GREEN indicates Information message, YELLOW indicates Warning message and RED indicates Error message.

In the present case; no inconsistencies have been found while starting All Servers. In case, there arise any warning or error messages, those problems are to be fixed and then select particular row of the warning/error message and click Completed.

General Log gives general information, while Monitor Volume gives detailed information of started server.

Once the warning is attended, select the row and hit Completed, which will going to turn yellow signal to green signal.

Tip: Every time inconsistencies are checked; General Log should be refreshed.

To select more than 1 message, keep Cntrl key pressed.

Global display; gives coverage results at author or package level according to criteria you select under Settings. It precisely gives high-level view.

Views can be based on Author or Package. ALL signifies all the authors on local system based on view given and the COND (y/z test groups) signifies all the authors on both local and remote systems based on view given. If ‘Other view' is selected as Package, then selection is done accordingly.

Note: Since Automatic Recordings were not switched on; percentage-based progress display over time cannot be seen for selected SAPDEV02 author.

Normally, Global display view gives Quality Managers to view the system performance and also to compare performance of two test-groups, the following way;

Unicode:

This value indicates how many percent of the processing blocks have the Unicode flag set (the flag itself is set per program)

Capacity Utilization:

This value is computed as the ratio of used processing blocks to loaded processing blocks to loaded processing blocks.

Accumulated Executions (Percent)

This value indicates in percent how many processing blocks have been executed since the start of the Coverage Analyzer.

Tested processing blocks (Percent)

This value indicates in percent how many processing blocks have been executed in the actual version without runtime errors.

In the figure above you can see that currently 98% of the processing blocks in the system belong to a program that has the Unicode flag set, 26% have been executed since start of the coverage analyzer, 9% have been executed in the active version without errors and the capacity utilization is 29%.

Exact Value Table can be viewed for author SAPDEV02; which displays number processing blocks for author SAPDEV02 on timely manner.

Graphical view of the selected row can be seen using icon; that displays graphical view of the individual date and all dates when no row is selected.

All rows selected for graphical analysis;

Individual selection for graphical analysis;

Tip: Moreover, previous saved history can also be viewed for the specific user.

Details display view; gives summarized and detailed results. It precisely gives low-level view.

Strong filtering options allow user to select on what conditions results are to be displayed.

Conditions can be set for range of test-groups, packages and authors pertaining to those test-groups.

In the present example; test-group ZTST and Author SAPDEV02 is taken as single-value selection, which gives results pertaining to specified criteria. Moreover, other filters can also be set and settings should be done defining access via Package Object, Package and Author. Defaulted access-via is Program Object.

Hitting Standard Settings is going to reset all the values.

Once settings are done; hit execute button, that is going to get detailed information, including number of calls made to that particular object, number of processing blocks, load size in Kilo byte. Besides all the information given; double-clicking the object name will navigate to the particular program or executing block where exactly error has been found.

Note: Current Executions = Program units currently used / Total no. of Program units.

Capacity Utilization = No. of Program units currently used / Loaded Program units.

Conclusion: Likewise, many such program executions, runtime errors and program resets can be easily traced using this powerful ABAP runtime analysis tool; Coverage Analyzer.

Zahack is an SAP ABAP Consultant at YASH Technologies.

Ways of Testing ABAP programs

2009-09-08T07:03:00.000-07:00

Viquar Iqbal
Business Card
Company: Yash Technologies
Posted on Sep. 02, 2009 03:59 AM in ABAP, Beginner, ERP

	Subscribe
	Print
	Permalink

ABAP testing is like a who-dunnit novel. You need to find out the runtime murderer of you program. As a developer I wanted to know what all can be done to test my program so that the client gets the best quality possible and without any embarrassing runtime dumps.

So I found out that there are 5 tools if not more, which can trace minute details after activating your program.

EPC- Extended program check
Code inspector
ABAP UNIT
ECATT
Coverage Analyzer

Many times it happens that we just do an EPC or SCI and say that the program is fine and can be delivered. But to check a program thoroughly with various test data we need to use at least 4 of the above test tools. Following is an overview of them.

Testing is generally divided between Static and Runtime Testing.

EPC and SCI are static.

ABAP UNIT, ECATT and Coverage analyzer fall in runtime testing category.

EPC (TCode: SLIN) - It checks the source code for various aspects like PERFORM/FORM interfaces, Problematic Statements etc. It's a good tool to remove potential runtime errors. So it's important that EPC gives your program a clean chit.

Code Inspector (TCode: SCI) - It's mostly used to check multiple programs. We can check for all the programs by a user, in a particular package etc. There are multiple options that you can choose from using SCI for example checking if all the programs are coded according to naming standards. You can also choose what to check in your program by selecting Goto->Management of -> Tests and select the class which handles the code check.

Once we statically check the program, we need to check for the reason program is made i.e. Runtime checks.

ABAP UNIT-We can access it in TCode -SE38. Under menu Program->test->Unit test. Most of the programs are modularized unit (form, function, or method). So, each block performs a specific functionality. Suppose the code is huge but modularized and it's giving incorrect output only for a particular field or particular functionality we can check only that particular module with test data to compare it with expected result. They are implemented as local object class in the same program whose unit is to be tested.

ECATT (TCode- SECATT) - It's also called integration test. After checking minute details, ECATT looks at the bigger picture. It checks if components of an application work well together .Its used for automated tests, we can run it across systems as well.It's a powerful scripting engine and editor for writing test scripts. It has many advantages like storing test data, reproduce the tests, integration of third party tools etc.

Coverage Analyzer (Tcode - SCOV) - It's used to monitor, system-wide execution of all parts (Modularization Units) of the program are executed over a period of time. It's also used for the execution of programs by a particular user group. There are many uses of SCOV like it helps to identify dead code , System wide execution (for RFC enabled FM ) , graphical display of program status( number of processing blocks loaded v/s Number of processing blocks used ), Option of filtering programs for monitoring ( Unicode enabled ) etc. It can be used both by Quality Managers as well as developers.

So if we make our programs go through these rigorous tests .In return we'll get satisfaction of a high quality product as well as a Very Happy Customer!

Further Readings

https://www.sdn.sap.com/irj/scn/weblogs?blog=/pub/wlg/15304

https://weblogs.sdn.sap.com/pub/wlg/15563

https://www.sdn.sap.com/irj/scn/weblogs?blog=/pub/wlg/3334

http://wiki.sdn.sap.com/wiki/x/Tw4

Viquar Iqbal is an Associate ABAP Consultant for Yash Technologies.

Nomen est Omen - ABAP Naming Conventions

2009-09-08T07:02:00.000-07:00

Uwe Schieferstein
Business Card
Company: Lindt & Spruengli (Schweiz) AG
Posted on Aug. 31, 2009 12:33 AM in ABAP, Standards

URL: https://www.sdn.sap.com/irj/scn/weblogs?blog=/pub/wlg/14901

	Subscribe
	Print
	Permalink

Introduction

My comment about the importance of ABAP naming conventions to Thorsten Franz' blog Great Programmers will their Code to the new Guy triggered an interesting discussion about naming conventions for ABAP. The opinions range from "...is important" to "...We do not advise you on naming conventions, do whatever you want".

The latter statement sounds like a capitulation. This resignation might be due to the following questions:

Are there useful naming conventions for ABAP? Apparently not even SAP has them.
Do naming conventions really improve ABAP coding and how?
How can we check the compliance of ABAP program objects with the naming conventions?

ABAP Naming Conventions: "Yes, we exist"
I started my SAP career more than 10 years ago at Cirrus Consulting. The very first thing I got there was a comprehensive documentation about ABAP naming and programming conventions which they had created for one of their biggest customers. And at the Zürcher Kantonalbank they had such a document, too.

Admittedly there were deviations from these conventions in particular because many external developers worked at these customers and the Code Inspector (SCI) was not yet available at that time. Nevertheless these conventions facilitated the readability of the coding and the handing over (for maintenance) to other developers. And if you look carefully around you will realize that even SAP (or at least a subset of its developers) uses naming conventions.

Now let us imagine a "...do whatever you want" customer where a developer creates a report (containing a constant for the speed of light) which in the subsequent years has been maintained by three other developers. Three of them use their own naming conventions and the forth one uses none at all so we may end up with the following representations of a single constant:

GC_LIGHTSPEED or LC_LIGHTSPEED
CO_LIGHTSPEED
C_LIGHTSPEED

The forth developer may replace all previous representations with his own SPEED_OF_LIGHT without any prefix because everybody "knows" that this is a (pyhsical) constant. This medley of naming conventions will definitely confuse every developer. And this is just a simple example considered with the mixing up the naming of global and local variables.

In the following section I will present my own naming conventions which are a "best-of-breed" blend of SAP naming conventions and those of my previous employers.

Call a Spade a Spade

Naming conventions must be concise, short and distinct. Any ambiguity is a burden for maintenance in the future. Using three categories of criteria it is possible to unambigously name virtually all variables and most signature parameters:

Visibility: Global / Local / Class Context
Type: Field / Structure / Table Type / Reference / Constants
Structural Context: FORM routines / Function Modules / Methods

There are two general naming conventions:

Variables and Class Attributes: __
Signature Parameters: __

Visibility & Type

We have three kinds of visibility: Global, Local and Class Context (which includes Interfaces as well) and seven different types (see below).

Visibility	Prefix	Type	Prefix	Example	Coding
Global	G	Field	D	GD_MATNR	DATA: gd_matnr TYPE matnr.
		Structure	S	GS_KNB1	DATA: gs_knb1 TYPE knb1.
		Table Type	T	GT_VBAK	DATA: gt_vbak TYPE TABLE OF vbak.
		Class	O	GO_GRID	DATA: go_grid TYPE REF TO cl_gui_alv_grid.
		Interface	IF	GIF_MSGLIST	DATA: gif_msglist TYPE REF TO if_reca_message_list.
		Data Object	DO	GDO_DATA	DATA: gdo_data TYPE REF TO data.
		Constant	C	GC_LIGHTSPEED	CONSTANTS: gc_lightspeed TYPE i VALUE '300000'.

Local	L	Field	D	LD_MATNR	DATA: ld_matnr TYPE matnr.
		Structure	S	LS_KNB1	DATA: ls_knb1 TYPE knb1.
		Table Type	T	LT_VBAK	DATA: lt_vbak TYPE TABLE OF vbak.
		Class	O	LO_GRID	DATA: lo_grid TYPE REF TO cl_gui_alv_grid.
		Interface	IF	LIF_MSGLIST	DATA: lif_msglist TYPE REF TO if_reca_message_list.
		Data Object	DO	LDO_DATA	DATA: ldo_data TYPE REF TO data.
		Constant	C	LC_LIGHTSPEED	CONSTANTS: lc_lightspeed TYPE i VALUE '300000'.

Class Context	M	Field	D	MD_MATNR	DATA: md_matnr TYPE matnr.
		Structure	S	MS_KNB1	DATA: ms_knb1 TYPE knb1.
		Table Type	T	MT_VBAK	DATA: mt_vbak TYPE TABLE OF vbak.
		Class	O	MO_GRID	DATA: mo_grid TYPE REF TO cl_gui_alv_grid.
		Interface	IF	MIF_MSGLIST	DATA: mif_msglist TYPE REF TO if_reca_message_list.
		Data Object	DO	MDO_DATA	DATA: mdo_data TYPE REF TO data.
		Constant	C	MC_LIGHTSPEED	CONSTANTS: mc_lightspeed TYPE i VALUE '300000'.

The vast majority of variables within program objects are either global or local. And in the future there will be a remarkably shift towards class attributes (ABAP-OO). Thus, assigning a unique prefix to each group makes their visibility unambigous for every developer.

Class attributes (instance and static) are special because they are global within the class/instance whereas they appear local from outside the class/instance. Without referring to a class(name) or instance these attributes are "hidden" (i.e. local).

Question: Does the type prefix offer any benefit?

In ABAP forum posts you may find the following definitions for ALV grid instances:

GRID: global (?), local (?), class context (?); class reference (?)
G_ALV_GRID: global (!?), local (?), class context (?); class reference (!?)
GO_GRID: global class reference OUTSIDE any class context (my naming convention)

Answer: Yes, because we meet the developer's expectation and anticipation.

You may argue: What a big fuss about such a little subtlety. My answer to this is: Every SAP developer who comes across a GO_GRID variable in any of my programs knows in advance(!) the meaning and scope of it.

Structural Context (1): FORM routine Signature

The SAP system does not care about which kind of formal parameters (USING or CHANGING) are used in FORM routine signatures. Both kinds of formal parameters can be changed within the routine and the modified contents transferred back to the calling program. This is ambiguity at its worst.

In order to make the signature of a FORM routine clear as crystal we define every Input = USING parameter and every Output = CHANGING parameter. Within the FORM routine all USING parameters should be regarded as "constants" meaning that they are not changed nor is any change transferred back to the calling program.

Parameter	Prefix	Type	Prefix	Example
USING	U	Field	D	UD_MATNR
		Structure	S	US_KNB1
		Table Type	T	UT_VBAK
		Class	O	UO_GRID
		Interface	IF	UIF_MSGLIST
		Data Object	DO	UDO_DATA

CHANGING	C	Field	D	CD_MATNR
		Structure	S	CS_KNB1
		Table Type	T	CT_VBAK
		Class	O	CO_GRID
		Interface	IF	CIF_MSGLIST
		Data Object	DO	CDO_DATA

Again, by defining Input = USING (prefix 'U') and Output = CHANGING (prefix 'C') we meet the developer's expectation and alleviate understanding of the FORM routine.

Structural Context (2): Function Module Signature

The same logic applies to function modules parameters. In addition, we can facilitate the understanding of TABLES parameters (Yes, I know they are obsolete yet some still like to use 'em) by the semantics of their Input/Output behaviour:

IT_ITAB = Input only
ET_ITAB = Output only
XT_ITAB = Input & Output

Parameter	Prefix	Type	Prefix	Example
IMPORTING	I	Field	D	ID_MATNR
		Structure	S	IS_KNB1
		Table Type	T	IT_VBAK
		Class	O	IO_GRID
		Interface	IF	IIF_MSGLIST
		Data Object	DO	IDO_DATA

EXPORTING	E	Field	D	ED_MATNR
		Structure	S	ES_KNB1
		Table Type	T	ET_VBAK
		Class	O	EO_GRID
		Interface	IF	EIF_MSGLIST
		Data Object	DO	EDO_DATA

CHANGING	C	Field	D	CD_MATNR
		Structure	S	CS_KNB1
		Table Type	T	CT_VBAK
		Class	O	CO_GRID
		Interface	IF	CIF_MSGLIST
		Data Object	DO	CDO_DATA

TABLES		"Importing"	IT	IT_VBAK
		"Exporting"	ET	ET_VBAK
		"Changing"	XT	XT_VBAK

Of course there is no technical difference whatsoever between "Importing", "Exporting" and "Changing" TABLES parameters. Yet the different naming gives the developer already an idea about the function of this module without looking into the coding. Or in other words: Try to "express" the function of the module already in its signature.

Structural Context (3a): Method Signature

The logic explained above is just applied to method parameters as well and extended to the additional RETURNING parameters of methods.

Parameter	Prefix	Type	Prefix	Example
IMPORTING	I	Field	D	ID_MATNR
		Structure	S	IS_KNB1
		Table Type	T	IT_VBAK
		Class	O	IO_GRID
		Interface	IF	IIF_MSGLIST
		Data Object	DO	IDO_DATA

EXPORTING	E	Field	D	ED_MATNR
		Structure	S	ES_KNB1
		Table Type	T	ET_VBAK
		Class	O	EO_GRID
		Interface	IF	EIF_MSGLIST
		Data Object	DO	EDO_DATA

CHANGING	C	Field	D	CD_MATNR
		Structure	S	CS_KNB1
		Table Type	T	CT_VBAK
		Class	O	CO_GRID
		Interface	IF	CIF_MSGLIST
		Data Object	DO	CDO_DATA

RETURNING	R	Field	D	RD_MATNR
		Structure	S	RS_KNB1
		Table Type	T	RT_VBAK
		Class	O	RO_GRID
		Interface	IF	RIF_MSGLIST
		Data Object	DO	RDO_DATA

Structural Context (3b): Static vs. Instance Attributes

Static attributes are special because they exist only once for all instances of this class. Modifying a static attribute within a given instance makes this change visible to all other instances. Both types of attributes have the prefix 'M' (class context) in my naming convention. In order to distinguish between static and instance attributes I apply the following convention:

Instance Attribute: with self-reference me-> (e.g. me->md_key)
Static Attribute: without self-reference (.e.g. ms_row)

You can find an example of this naming convention in the coding of INCLUDE ZRSWBOSDR_C01 in my blog Multi-Purpose ALV Programming.

Another unambigous convention is to drop the self-reference prefix and use the full qualified name for static attributes:

Instance Attribute: md_key (with or with self-reference prefix)
Static Attribute: lcl_eventhandler=>ms_row

Field-Symbols

We can apply the same naming conventions even to field-symbols which makes them much more readable and understandable for every developer. This is particularly important because the contents of field-symbols cannot be analyzed statically but is only determined at runtime.

Visibility	Prefix	Type	Prefix	Example
Global	G	Field	D
		Structure	S
		Table Type	T
		Class	O
		Interface	IF
		Data Object	DO

Local	L	Field	D
		Structure	S
		Table Type	T
		Class	O
		Interface	IF
		Data Object	DO

SAP and Lego

Why has Lego become one of the world's most famous toys? Part of the answer can be found here:

"Lego pieces of all varieties are a part of a universal system. Despite variation in the design and purpose of individual pieces over the years, each remains compatible in some way with existing pieces. Lego bricks from 1958 still interlock with those made in 2009, and Lego sets for young children are compatible with those made for teenagers.

Bricks, beams, axles, mini figures, and all other parts in the Lego system are manufactured to an exacting degree of precision. When snapped together, pieces must have just the right amount of strength and flexibility mixed together to stick together. They must stay together until pulled apart. They cannot be too easy to pull apart, or the resulting constructions would be unstable; they also cannot be too difficult to pull apart, since the disassembly of one creation in order to build another is part of the Lego appeal. In order for pieces to have just the right "clutch power", Lego elements are manufactured within a tolerance of 2 µm."

QUESTION: "Have you ever seen a child which sits in front of a pile of Lego bricks claiming it can't build anything because all bricks have the same size???"

For me SAP is just an incredibly huge pile of Lego bricks (for grown-ups). Consistent naming conventions are an indispensable standard which enables us to manufacture long-lasting developments that are easy to understand and maintain (pull apart and reassemble).

Code Inspector: Check Compliance with your Naming Conventions

The Code Inspector (transaction SCI) provides you with all means to check compliance with your naming conventions. Within the check variant you an explicit check Programming Conventions.

Looking at the check Naming Conventions a popup appears where you can define your conventions for data variables and signatures (FORM routine, function module, classes).

Since I have not yet mentioned macros (DEFINE) yet here is my convention:

MAC_: e.g. mac_suppress_toolbar_btn

Another set of frequently used global variables are (select-)parameters and select-options:

SELECT-OPTIONS:

S_MATNR FOR mara-matnr.

PARAMETERS:

P_MATKL TYPE matkl.

Looking at the check Extended Naming Conventions for Programs you will find my 7 types (Field, Structure, Table Type, Class, Interface, Data Object, Constant) grouped into 5 prefixes:

Elementary Type includes Field and Constant
Object Reference includes Class and Interface

The prefixes shown above are the default values when opening the check with which I do not agree. For example, the prefix "R" indicates a global range according to my conventions:

DATA: rt_matnr TYPE RANGE OF matnr.

Summary

It is possible to define useful naming conventions for ABAP. Naming conventions significantly help in understanding a program and navigating around it. Both the new and the senior guy will benefit in particular when it comes to maintenance because they can focus their analysis on the program logic and not the "logic" of the previous developer.

Conclusions

Naming conventions are not impositions for creative developers but, on the contrary, side rails for long-lasting development.

Further Readings

Great Programmers will their Code to the New Guy

The Little SE80 of Horrors

Random Ramblings of an obsolete programmer

Uwe Schieferstein is a SAP developer / SAP-XI consultant for Lindt & Spruengli (Schweiz) AG currently focusing on EDI integration.

Sending E-Mail from ABAP - Version 610 and Higher - BCS Interface

2009-08-14T00:48:00.000-07:00

Blogs

Sending E-Mail from ABAP - Version 610 and Higher - BCS Interface
Thomas Jung
Business Card
Company: SAP Labs, LLC
Posted on Sep. 08, 2004 03:13 AM in ABAP, Application Server

	Subscribe
	Print
	Permalink

Introduction
There seems to be a lot of requests in the forums for tips on how to send E-Mail from ABAP. Based upon these requests, I thought I would pull together some resources and samples on the subject. The setup and samples are quite different on different releases. Yesterday I posted a weblog for releases <=46D that used the API function modules. This weblog focuses on releases 610 and higher. There are many changes in this release. For one there is no longer any reliance on external executables to send the mail. The SAP Kernel now contains native SMTP processing capabilities in the Internet Connection Manager (ICM). Also we have a new ABAP interface that can be used called the Business Communication Services (BCS). All samples came from a 620 system.

Configuration
Before we start with any ABAP coding, we first have to setup and configure a few things. Much of this configuration may have already been completed by your Basis group. ICM Setup
Unlike in release 46D and lower, we have no external executables to setup. There is no need to configure the Internet Mail Gateway or create any RFC destinations. However there is some setup that needs to be done to the ICM to activate and configure SMTP processing. OSS Note 455140 gives an excellent step-by-step guide to configuring SMTP. I will just give you a quick check list here without going into all the configuration details provided by this note.
1. If you are one release 610 only, you must add the SMTP Plug-In entry in your instance profile. This is not needed as of release 620 because the system is delivered with SMTP as an integrated part of the ICM.
2. In the instance profile, specify the TCP/IP port that SMTP will listen on. Port 25 is the default.
3. If you have multiple clients in your SAP system, you will want to setup a virtual host for each client.
4. Verify in transaction SICF that you have a SMTP node and that it is activated. It should look something like the following:
SAPConnect
Well we are finished with all the low level setup. Now we need to connect the lowest layer (the ICM) to SAP's middle message layer: SAPConnect. SAPConnect sits between the application layer (such as SAP Office) and the lowest layer hiding all the technical details. All of the SAPConnect monitoring and configuration can be reached from one transaction called SCOT. First SCOT has several different views that can be used. One shows the Jobs that have been setup, the other shows setup by routings, etc. I prefer to start SCOT in System Status View. This shows a tree with the communication types, the nodes setup for each type and the number of messages in each status. The following is a screen shot of this view:
We want to create a new node in SAPConnect for our E-Mail. As of release 46C you have a quite nice Wizard that walks you through the process. However you can also control all settings directly in a dialog maintenance window. This is a screen shot of our Email Node.
You can see that to setup this node all we have to do is specify the connection information for an external mail server. In our case we give the host name for our Corporate Microsoft Exchange Server. Also at this level we can specify the code page that we want all messages converted to before they are sent. I choose Unicode UTF-8 because we have an MDMP system that contains English, German, Spanish, Thai, and Polish languages. By converting to UTF-8 we get around the problem described in OSS note 331418. You do NOT have to have a Unicode system or kernel to support this functionality. Please refer to OSS Note 633265 for the necessary support package levels for this functionality to be complete. Now lets look at the configuration on our only configured address type: Internet. We don't do any outbound filtering to different nodes. Therefore the address areas is set to the wildcard '*'. To comply with the Unicode setup we have all output formats being converted to PDF as OSS note 633265 suggests.
Next we need to schedule a job that will transmit out E-mails. Normally E-Mails will only go out when this job runs, so you probably want to schedule it quite frequently. (Later in my code example, I will show you how using the BCS interface you can send E-mails immediately as well). In our production system we run this job every 5 minutes. The job setup can also be done from SCOT. Switch your view to JOBS. You can then hit CREATE to start the process of scheduling a new Send Job. Running a Test
We are just about ready to run our first test. The only other requirement is that the sender of any E-mail, must have their return address setup in their user master. If you don't maintain this data, you will get a send error. If you want an SAP program to generate these addresses for you, have a look at OSS note 104263. Also in 46C and higher you have the option to configure the system to generate the sender address on the fly. OSS note 320443 gives you the details of this solution. You can see from the following screen shot the field that must be maintained in the user master:
Let's try a test now. I like to start by testing using the SAP short message functionality. You will want to use menu System->Short Message. From here we will prepare a short test message. If you don't want to wait for your batch job to run to find out if your message went through, just jump back to transaction SCOT. From the System Status view you can choose Ctrl+F7 or the Execute Icon to start the send process for a communication type. You should receive your test message if everything is setup fine. Trouble Shooting
Let's say that everything didn't go fine. Where do we start trouble shooting? Once again start with the transaction SCOT. The system status shows us our status overview. You can see the number of messages in Error or Waiting. If you have a lot of messages in Waiting status, your send job probably isn't scheduled. The overview screen is nice, but you probably want more details. From SCOT you can choose Utilities->Overview of Send Orders (Or Tcode SOST). This transaction will give a detailed report by Address type, status, date, time and sender. For each message we can view the transmission history, the message itself, and the trace log. You can also try and resubmit the message from here. If you need to activate tracing, you want to return to transaction SCOT. You then choose Utilities->Trace->Internal Trace. You can also view all traces from here without having to go through SOST. ABAP Coding
If everything has worked up to this point, then you are ready to start writing your own E-mail calls in ABAP. The example I am going to share with you is actually a function module that we wrote. We wanted to write a function module that would really simplify the process of sending E-mail for our newer ABAP developers. We wanted them to just specify a few parameters and be off and running without having to understand the BCS classes. Hopefully you will find this function module helpful as well as being a good tutorial on how to use the BCS classes. Function Interface
The function module Interface is quite simple in that it only has 3 input parameters.
The first is an optional parameter used to set what requested statuses types will be returned. You can specify N for No Statuses, E for Only Error Statuses, or A for All Statuses. The second parameter is an internal table that will hold all of our document parts. The following is the line type that defines this internal table type:

The first entry in this table will become our E-Mail Body. All other parts will become attachments in the email. For each record in this table you must specify the document type as a value defined in the foreign key table TSOTD. You can also supply the subject line (or attachment name) in the subject field. You can then specify the content of this document part in either the CONTENT_TEXT (ASCII text) or CONTENT_HEX (Binary data such as PDFs). You will notice that the structure of these two content areas match those used by the API function modules in 46D and lower. This makes for a very easy change from the API function modules to the BCS Classes. The third parameter is another internal table that will hold all of our recipients. The following is the line type that defines this internal table type:

The calling program has the choice of setting a full email address directly into the C_ADDRESS field or just specifying an SAP User ID in the UNAME field. If the calling program chooses to use the UNAME field, the function module will lookup the user's E-Mail address from their user master record. Finally there are several flags that can be set per recipient such as No Forward, Express Message, etc. The function module has no Exporting, Changing, or table parameters. The only exception that is returned is the BCS Exception class itself: CX_BCS.
Function Module Code
We start off the coding in our function module with a few class definitions. We then some variable declarations.

*----------------------------------------------------------------------* * CLASS-DEFINITIONS                                                    * *----------------------------------------------------------------------*   DATA: send_request       TYPE REF TO cl_bcs.   DATA: document           TYPE REF TO cl_document_bcs.   DATA: sender             TYPE REF TO cl_sapuser_bcs.   DATA: recipient          TYPE REF TO if_recipient_bcs.   DATA: exception_info     TYPE REF TO if_os_exception_info,         bcs_exception      TYPE REF TO cx_bcs.  *----------------------------------------------------------------------* * INTERNAL TABLES                                                      * *----------------------------------------------------------------------*   DATA: l_mailtext TYPE soli_tab.   DATA: l_mailhex  TYPE solix_tab.   DATA: iaddsmtp   TYPE bapiadsmtp OCCURS 0 WITH HEADER LINE.   DATA: ireturn    TYPE bapiret2 OCCURS 0 WITH HEADER LINE.  *----------------------------------------------------------------------* * VARIABLES                                                            * *----------------------------------------------------------------------*   DATA: mail_line  LIKE LINE OF l_mailtext.   DATA: mailx_line LIKE LINE OF l_mailhex.   DATA: bapiadsmtp         TYPE bapiadsmtp.  *----------------------------------------------------------------------* * CONSTANTS                                                            * *----------------------------------------------------------------------*   CONSTANTS:     kimball_domain(12) TYPE c VALUE '@kimball.com'.    CLASS cl_cam_address_bcs DEFINITION LOAD.   CLASS cl_abap_char_utilities DEFINITION LOAD.

Next we start the execution code itself. We will wrap all of our code inside a try...catch statement in order to trap any BCS errors. We will then start by creating an instance of the BCS persistent class that we will call send_request.
Now we are ready to create the e-mail content itself. The first record in our documents importing parameter will become the main e-mail document. All other content will be inserted as attachments to this document.

DATA: first(1) TYPE c.       CLEAR first.       DATA: documents_line LIKE LINE OF documents.        LOOP AT documents INTO documents_line.         IF first IS INITIAL.           MOVE 'X' TO first. * Build the Main Document           IF documents_line-content_hex[] IS INITIAL.             document = cl_document_bcs=>create_document(                                 i_type    = documents_line-type                                 i_text    = documents_line-content_text                                 i_subject = documents_line-subject ).           ELSE.             document = cl_document_bcs=>create_document(                                 i_type    = documents_line-type                                 i_hex     = documents_line-content_hex                                 i_subject = documents_line-subject ).           ENDIF.         ELSE.           IF documents_line-content_hex[] IS INITIAL. * Add Attachment             CALL METHOD document->add_attachment               EXPORTING                 i_attachment_type    = documents_line-type                 i_attachment_subject = documents_line-subject                 i_att_content_text   = documents_line-content_text.           ELSE.             CALL METHOD document->add_attachment               EXPORTING                 i_attachment_type    = documents_line-type                 i_attachment_subject = documents_line-subject                 i_att_content_hex    = documents_line-content_hex.           ENDIF.         ENDIF.       ENDLOOP.

Now we can add our document (and its attachments) to our send request.
Next we will create a sender object (this function module automatically uses the current user) and place it into our send request.
Following the sender, we can add our recipients to the e-mail. If requested by the calling program we will lookup the recipients e-mail address from their SAP User Master using the BAPI, BAPI_USER_GET_DETAIL. If an e-mail address isn't maintained there, we will try and create one by concatenating their user id together with our default company domain name.

DATA: recipients_line LIKE LINE OF recipients.       LOOP AT recipients INTO recipients_line.         IF recipients_line-c_address IS INITIAL. * Create recipient           CLEAR iaddsmtp.           REFRESH iaddsmtp.           CLEAR bapiadsmtp.           CLEAR recipient. * Read the E-Mail address for the user           CALL FUNCTION 'BAPI_USER_GET_DETAIL'             EXPORTING               username = recipients_line-uname             TABLES               return   = ireturn               addsmtp  = iaddsmtp.           LOOP AT iaddsmtp WHERE std_no = 'X'.             CLEAR bapiadsmtp.             MOVE iaddsmtp TO bapiadsmtp.           ENDLOOP. * If no E-mail address was found, create one.           IF bapiadsmtp-e_mail = ''.             CONCATENATE recipients_line-uname kimball_domain                       INTO recipients_line-c_address.           ELSE.             MOVE bapiadsmtp-e_mail TO recipients_line-c_address.           ENDIF.         ENDIF.          recipient = cl_cam_address_bcs=>create_internet_address( recipients_line-c_address ). * Add recipient with its respective attributes to send request         CALL METHOD send_request->add_recipient           EXPORTING             i_recipient  = recipient             i_express    = recipients_line-i_express             i_copy       = recipients_line-i_copy             i_blind_copy = recipients_line-i_blind_copy             i_no_forward = recipients_line-i_no_foward.        ENDLOOP.

We are almost done now. All we have to do is set the return status attributes of the message.
Remember earlier that I said that e-mails had to wait for a job to run to actually send them out. Well here is opportunity to by-pass this job and send them immediately. The E-mails still get logged in the system and can be monitored from SCOT (or SOST). The following code will trigger the send immediately.
Finally we tell the system to send our email. We follow this up with a commit work statement. Because the BCS is written as a Persistent Object Class, no activity will take place until we trigger the commit work. We close by catching the BCS errors into the BCS exception class.
Finally here is the complete code sample provided for easier viewing:

FUNCTION z_e_keg_send_simple_email. *"---------------------------------------------------------------------- *"*"Local interface: *"  IMPORTING *"     VALUE(REQUESTED_STATUS) TYPE  BCS_RQST DEFAULT 'E' *"     VALUE(DOCUMENTS) TYPE  ZES_KEG_EMAIL_DOCUMENTS *"     VALUE(RECIPIENTS) TYPE  ZES_KEG_EMAIL_RECIPIENTS *"  RAISING *"      CX_BCS *"----------------------------------------------------------------------  *----------------------------------------------------------------------* * CLASS-DEFINITIONS                                                    * *----------------------------------------------------------------------*   DATA: send_request       TYPE REF TO cl_bcs.   DATA: document           TYPE REF TO cl_document_bcs.   DATA: sender             TYPE REF TO cl_sapuser_bcs.   DATA: recipient          TYPE REF TO if_recipient_bcs.   DATA: exception_info     TYPE REF TO if_os_exception_info,         bcs_exception      TYPE REF TO cx_bcs.  *----------------------------------------------------------------------* * INTERNAL TABLES                                                      * *----------------------------------------------------------------------*   DATA: l_mailtext TYPE soli_tab.   DATA: l_mailhex  TYPE solix_tab.   DATA: iaddsmtp   TYPE bapiadsmtp OCCURS 0 WITH HEADER LINE.   DATA: ireturn    TYPE bapiret2 OCCURS 0 WITH HEADER LINE.  *----------------------------------------------------------------------* * VARIABLES                                                            * *----------------------------------------------------------------------*   DATA: mail_line  LIKE LINE OF l_mailtext.   DATA: mailx_line LIKE LINE OF l_mailhex.   DATA: bapiadsmtp         TYPE bapiadsmtp.  *----------------------------------------------------------------------* * CONSTANTS                                                            * *----------------------------------------------------------------------*   CONSTANTS:     kimball_domain(12) TYPE c VALUE '@kimball.com'.    CLASS cl_cam_address_bcs DEFINITION LOAD.   CLASS cl_abap_char_utilities DEFINITION LOAD.    TRY. * Create persistent send request       send_request = cl_bcs=>create_persistent( ).        DATA: first(1) TYPE c.       CLEAR first.       DATA: documents_line LIKE LINE OF documents.        LOOP AT documents INTO documents_line.         IF first IS INITIAL.           MOVE 'X' TO first. * Build the Main Document           IF documents_line-content_hex[] IS INITIAL.             document = cl_document_bcs=>create_document(                                 i_type    = documents_line-type                                 i_text    = documents_line-content_text                                 i_subject = documents_line-subject ).           ELSE.             document = cl_document_bcs=>create_document(                                 i_type    = documents_line-type                                 i_hex     = documents_line-content_hex                                 i_subject = documents_line-subject ).           ENDIF.         ELSE.           IF documents_line-content_hex[] IS INITIAL. * Add Attachment             CALL METHOD document->add_attachment               EXPORTING                 i_attachment_type    = documents_line-type                 i_attachment_subject = documents_line-subject                 i_att_content_text   = documents_line-content_text.           ELSE.             CALL METHOD document->add_attachment               EXPORTING                 i_attachment_type    = documents_line-type                 i_attachment_subject = documents_line-subject                 i_att_content_hex    = documents_line-content_hex.           ENDIF.         ENDIF.       ENDLOOP.   * Add document to send request       CALL METHOD send_request->set_document( document ).  * Get sender object       sender = cl_sapuser_bcs=>create( sy-uname ).  * Add sender       CALL METHOD send_request->set_sender         EXPORTING           i_sender = sender.         DATA: recipients_line LIKE LINE OF recipients.       LOOP AT recipients INTO recipients_line.         IF recipients_line-c_address IS INITIAL. * Create recipient           CLEAR iaddsmtp.           REFRESH iaddsmtp.           CLEAR bapiadsmtp.           CLEAR recipient. * Read the E-Mail address for the user           CALL FUNCTION 'BAPI_USER_GET_DETAIL'             EXPORTING               username = recipients_line-uname             TABLES               return   = ireturn               addsmtp  = iaddsmtp.           LOOP AT iaddsmtp WHERE std_no = 'X'.             CLEAR bapiadsmtp.             MOVE iaddsmtp TO bapiadsmtp.           ENDLOOP. * If no E-mail address was found, create one.           IF bapiadsmtp-e_mail = ''.             CONCATENATE recipients_line-uname kimball_domain                       INTO recipients_line-c_address.           ELSE.             MOVE bapiadsmtp-e_mail TO recipients_line-c_address.           ENDIF.         ENDIF.          recipient = cl_cam_address_bcs=>create_internet_address( recipients_line-c_address ). * Add recipient with its respective attributes to send request         CALL METHOD send_request->add_recipient           EXPORTING             i_recipient  = recipient             i_express    = recipients_line-i_express             i_copy       = recipients_line-i_copy             i_blind_copy = recipients_line-i_blind_copy             i_no_forward = recipients_line-i_no_foward.        ENDLOOP.  * Set that you don't need a Return Status E-mail       DATA: status_mail TYPE bcs_stml.       status_mail = requested_status.       CALL METHOD send_request->set_status_attributes         EXPORTING           i_requested_status = requested_status           i_status_mail      = status_mail.  * set send immediately flag       send_request->set_send_immediately( 'X' ).  * Send document       CALL METHOD send_request->send( ).        COMMIT WORK.      CATCH cx_bcs INTO bcs_exception.       RAISE EXCEPTION bcs_exception.    ENDTRY. ENDFUNCTION.

Thomas Jung is an SAP NetWeaver Product Manager focusing on Custom Development - including ABAP, MDM APIs, UI Strategy, and NetWeaver Voice.

Basic ABAP OO eLearnings

2009-08-12T00:18:00.000-07:00

Blogs

Basic ABAP OO eLearnings
Thomas Jung
Business Card
Company: SAP Labs, LLC
Posted on Aug. 11, 2009 06:29 AM in ABAP, Beginner, Business Server Pages, Web Dynpro

	Subscribe
	Print
	Permalink

Introduction

This blog introduces a 5 part eLearning series based upon a frequent request – to look at basic ABAP Object Oriented concepts. Throughout this series we will look at OO terminology, development tools, and design patterns that span a variety of ABAP release levels. We will try to keep the discussion away from all the new cutting edge syntax so that it is still quite usable for those of you on older releases like 4.6C or 6.20.

For the 5 part series we will start with Part 1 looking at tooling (the ABAP Class Builder) and some basic terminology. In Part 2 we will expand the lesson by looking at static vs. instance, visibility, exception classes, inheritance, polymorphism and abstract classes. In part 3 we will see how a special type of class, called a persistent object, can be used for Object Oriented access to the database. In part 4 we will explore Object Oriented concepts in User Interface technologies. Keeping with the theme of older release levels, we will focus this part on using Model View Controller and OO eventing within Classic Dynpro applications. Finally in part 5 we will look at real world, complex example that uses all the techniques and technologies from the previous parts.

Part 1 - Basics

In Part1 of the eLearning we start with the very most basic concepts. We will explore the class builder tool within SE80 and discuss some of the terminology that you need to know in order to begin to learn Object Oriented design and development.

Part 1 Video Running Time: 53 Minutes

Part 2 - Classes, Inheritance, Visibility, Polymorphism

In this part, we will expand the lesson by looking at static vs. instance, visibility, exception classes, inheritance, polymorphism and abstract classes. We start with a very basic class with only static methods that works very much like a Function Group/Function Modules. Next we change the methods into instance methods and see how a class instance allows us to model complex data structures and relationships in code. Then we see how exception classes can make our exceptions more meaningful and simplify the surrounding code for dealing with exceptions. Finally we see the real power of object oriented design come to life as we use inheritance and polymorphism to hide the inner complexity of our business logic from calling applications all while ensuring uniform execution of our code. These techniques may feel foreign at first, but in the long run they lead to code that is easier and safer to maintain.

Part 2 Video Running Time: 1 Hour, 10 Minutes

Part 3 - Persistant Objects

In this part, we will expand the lessons of the previous tutorial and look at a special type of class in ABAP – the Persistent Object. Persistent Objects are an OO-based approach to the types of data access that you would normally perform with SQL statements. With Persistent Objects you don’t code any SQL statements. Instead a class is generated for you that contains SET and GET methods for reading and updating data. ABAP Persistent Objects also contain the functionality for more complex update scenarios – like V2 Asynchronous updates.

Part 3 Video Running Time: 1 Hour, 9 Minutes

Part 4 - User Interface

In this part, we look at the special use case of Object Oriented technology and design techniques as they are applied to User Interface creation. Throughout all the ABAP UI technologies, we study how MVC (Model View Controller) design can be applied. We look briefly at BSP and Web Dynpro ABAP and OO effects the overall design as well as specific features like UI element rendering and eventing. We close with an example of how you can adapt even Classic Dynpro and its PBO/PAI processing looks to a more Object Oriented MVC flow.

Part 4 Video Running Time: 1 Hour

Part 5 - Putting It All Together

In this final entry in the 5 part ABAP OO series, we examine examples of how SAP puts the techniques that we learned in the previous 4 sessions to work within the standard code that they deliver to customers. We start by looking at the CL_BCS classes for sending email. CL_BCS* serves as a perfect example of the use of Persistent Objects and Polymorphism. We also look at the functionality behind the new ABAP Code Completion feature in the ABAP Editor. This block of code uses Persistent Objects, Inheritance/Polymorphism, Exception Classes, and MVC structured Classic Dynpro.

Part 5 Video Running Time: 42 Minutes

Source Code

Source Code Download

The source code for this tutorial is provided in two different formats. The directories cofiles and data contain ABAP transport files with all the development objects contained in this tutorial. If you have access and permission to import transport files from external systems, this can be a good way to import the tutorial source code. All objects are imported at once and all development object types are supported. However you should only use this approach if you are importing into a 7.0 or higher level system. The transport files contain development objects (like Web Dynpro ABAP) that only exist at this development level. If you import the transport in earlier releases, you will receive import errors.

The other solution is to import the development objects using SAPlink. SAPlink is not an SAP provided or supported solution. It is a community created project for exporting and importing ABAP development objects in XML format. You can read more about SAPlink at http://www.saplink.org.

The SAPlink files are the ones with the file extension NUGG. I have divided the SAPlink files into smaller groups so that you can import just the objects that you want and avoid technologies that might not be supported on your release level. The main drawback to SAPlink is that it doesn't have a plug-in that supports persistent objects. Therefore it is not possible to include the persistent classes from Part 3 of the Tutorial. I have still included the data dictionary objects and programs from this section of the tutorial.

The following is the listing of the SAPlink objects and the suggested order of import:

NUGG_AFS_OO - these are basic classes and programs from Tutorial #1 and #2. They should be usable back to WebAS 6.10 and higher based releases.
NUGG_AFS_OO_PERSISTENT_DDIC - these are the only the data dictionary objects used in Tutorial #3.
NUGG_AFS_OO_PERSISTENT_PROGRAMS - these are the dynpro programs that are used to test the persistent classes from Tutorial #3. They need the persistent objects that cannot be offered via SAPlink. You would need to create the persistent objects manually before you could import these programs
without error.
NUGG_AFS_OO_PERSISTENT_PROGRAMS_702 - These would mostly be an item of curiosity. For proper import they would require an ABAP 7.02 based system (which isn't available yet as of Aug 2009) or NetWeaver 7.1x or higher (of which there is not version of the Business Suite that runs on this
NetWeaver release). Chances are low that there are many people who could import these objects without syntax errors. However knowing this, you might still want to study the code to see what will be possible in the near future.
NUGG_AFS_OO_UI_DDIC - From Tutorial #4 - these are the data dictionary objects that are used throughout the UI based tutorials. Please import these before any of the other UI tutorials and regardless of which UI technology tutorials you are importing.
NUGG_AFS_OO_UI_DYNPRO - From Tutorial #4 - these are the classic dynpro based tutorials and can be imported into any release level supported by SAPlink (technically the demos should work back in 4.6C as well if you want to recreate them manually).
NUGG_AFS_OO_UI_BSP - From Tutorial #4 - these are the BSP (Business Server Pages) related examples. Only import them into a WebAS 6.20 or higher based release level.
NUGG_AFS_OO_UI_WDA - From Tutorial #4 - these are Web Dynpro ABAP related examples. Only import them into a NetWeaver 7.0 or higher based release level.

Thomas Jung is an SAP NetWeaver Product Manager focusing on Custom Development - including ABAP, MDM APIs, UI Strategy, and NetWeaver Voice.

SAP IDES ECC 5+ Demo flight Data Generation

2009-06-05T00:52:00.000-07:00

Buddy, I was wondering a while for seeking the T.Code to create demo data for Flight model for training purpose. Finally, the beauty just comes to me, :D. Its T.Code is BC_DATA_GEN.

Good luck buddies.

FM Parsing Select option for displaying in ALV header

2009-04-13T20:52:00.001-07:00

*&---------------------------------------------------------------------*
*& Form f_parse_select_option
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* -->SIGN text
* -->OPTION text
* -->LOW text
* -->HIGH text
* -->TEXT text
*----------------------------------------------------------------------*
form f_parse_select_option tables t_sel
changing o_text.
constants lt_e_txt type c length 3 value '#'.
data: li_length type i.
field-symbols: <fs> type any,
<sign> type any,
<option> type any,
<low> type any,
<high> type any.
loop at t_sel[] assigning <fs>.
assign component 'SIGN' of structure <fs> to <sign>.
assign component 'OPTION' of structure <fs> to <option>.
assign component 'LOW' of structure <fs> to <low>.
assign component 'HIGH' of structure <fs> to <high>.
case <sign>.
when 'I'.
case <option>.
when 'EQ'.
concatenate o_text <low> into o_text separated by space.
when 'NE'.
concatenate lt_e_txt o_text <low> into o_text separated by space.
when 'GE'.
concatenate o_text '>=' <low> into o_text separated by space.
when 'GT'.
concatenate o_text '>' <low> into o_text separated by space.
when 'LE'.
concatenate o_text '<=' <low> into o_text separated by space.
when 'LT'.
concatenate o_text '<' <low> into o_text separated by space.
when 'BT'.
concatenate o_text '[' <low> '->' <high> ']' into o_text separated by space.
when 'NB'.
concatenate o_text ']' <low> '->' <high> '[' into o_text separated by space.
when 'CP'.
concatenate o_text <low> into o_text separated by space.
when 'NP'.
concatenate o_text lt_e_txt <low> into o_text separated by space.
endcase.
when 'E'.
case <option>.
when 'EQ'.
concatenate o_text lt_e_txt <low> into o_text separated by space.
when 'NE'.
concatenate o_text <low> into o_text separated by space.
when 'GE'.
concatenate o_text lt_e_txt '>=' <low> into o_text separated by space.
when 'GT'.
concatenate o_text lt_e_txt '>' <low> into o_text separated by space.
when 'LE'.
concatenate o_text lt_e_txt '<=' <low> into o_text separated by space.
when 'LT'.
concatenate o_text lt_e_txt '<' <low> into o_text separated by space.
when 'BT'.
concatenate o_text ']' <low> '->' <high> '[' into o_text separated by space.
when 'NB'.
concatenate o_text '[' <low> '->' <high> ']' into o_text separated by space.
when 'CP'.
concatenate o_text lt_e_txt <low> into o_text separated by space.
when 'NP'.
concatenate o_text lt_e_txt <low> into o_text separated by space.
endcase.
endcase.
concatenate o_text '/' into o_text separated by space.
endloop.
condense o_text.
li_length = strlen( o_text ) - 1.
o_text = o_text+0(li_length).
condense o_text.
endform. "f_parse_select_option

BAPI for Details of Sales Order

2009-03-30T20:25:00.001-07:00

BAPISDORDER_GETDETAILEDLIST

User Exits & BADIs

2008-11-20T23:44:00.000-08:00

So, just KIS, what are they?

First, User Exist, according to the definition in SAP Wiki, is "a common term that is used when we need to do any extra specific functionality over and above the SAP standard coding. User exits are anticipated point of enhancement delivered by SAP. These user exits are nothing but well defined interfaces and are stable."

So, BADIs is like User Exit but implemented using ABAP Objects.

ABAP Objects in Action: Screen Programming with the Control Framework

2008-11-05T23:45:00.000-08:00

ABAP Objects in Action: Screen Programming with the Control Framework

by Horst Keller and Gisbert Loff, SAP

Categories: Development/Programming

This article demonstrates how to use controls with ABAP Objects to program single-screen user interfaces. It also takes you step-by-step through the development process and provides sample code that serves as a starting point for creating more inviting user interfaces.

If you have attended a recent training class or SAP demonstration where SAP's "flight model" was used as a database, you should recognize the abbreviations AA, AZ, and so on, shown on the flight information screen in Figure 1. But compared to classical training examples, the screen in Figure 1 is much fancier. The upper left portion shows an airplane graphic that has no functionality - it is for visual purposes only. On the lower left is a tree structure, from which users can select carriers or flight connections from SAP's flight model. The third pane displays the Web site of the selected carrier or the detail lists for flight connections.

This is just one example of the kinds of easy-to-use, easy-to-navigate interfaces that you can provide users when you combine the strengths of GUI control technology with ABAP Objects.

In this article, we show you how to use controls with ABAP Objects to program single-screen user interfaces. After providing an overview of the control framework, we will take you step by step through the development process and provide some sample code - which will run in R/3 Release 4.6 - that you can use as a starting point for creating more inviting user interfaces in your own applications.

Figure 1

User Interface of the Flight Model Program

Control Technology Overview

The R/3 system communicates with the user via screens on the frontend. In classical ABAP programming, screens may contain input/output fields, checkboxes, radio buttons, and push buttons to interact with the user.

All user actions that raise the runtime event PAI (Process After Input) and the respective processing on the application server are connected to a function code that is transported to the application server.¹

Controls in General

Controls are independent software components that are shipped with the SAP GUI, beginning with Release 4.5. You can place controls on screens to either replace or work alongside classical components - both are supported in parallel. SAP currently supports ActiveX controls for Microsoft Windows platforms and JavaBeans for the SAP GUI in the Java environment.

Note that controls provide a great deal of functionality and can keep a lot of data at the presentation server without putting weight on the application server (for example, during scrolling and editing of texts). On the other hand, frequent data exchange between the frontend and backend may increase the network load. Therefore, controls are appropriate when most of the work can be done at the frontend and when exchange with the backend does not occur too often.

Control Framework

In order to facilitate programming with controls, starting with Release 4.6, the SAP Basis system provides a control framework (CFW). The CFW encapsulates all available controls in global classes of ABAP Objects. To work with controls on your screen, simply create objects of these global classes, call their methods, and react on their events. Since the CFW classes are part of an inheritance hierarchy, these classes provide a standardized interface for most of the common functionality you will find in the controls.

The CFW distinguishes between container controls and application controls. Application controls are the components you want to use on the screen. Container controls provide a software layer that standardizes all layout-related issues and the implementation of application controls. All application controls must be linked to a container control while the container control is linked to an area of the screen (see Figure 2).

Figure 2

Container Controls and Application Controls on Screens

Container Controls

Container controls provide areas on the screen that can be used for application controls. The most important container controls are encapsulated in the following global classes²:

CL_GUI_CUSTOM_CONTAINER: When you create an object of this class, you must link it to a custom control on a screen via the IMPORTING parameter container_name of its constructor. You can use the Screen Painter to create one or several custom controls within the area of one screen, and you can use custom controls together with classical screen elements. Any application control that you link to a custom container will appear within its screen area.
CL_GUI_DOCKING_CONTAINER: When you create an object of this class, you must link it to one of the four edges of a screen. By doing so, you create a new area docked to a screen without using the Screen Painter. Any application control that you link to a docking container will appear within that screen area.
CL_GUI_SPLITTER_CONTAINER: When you create an object of this class, you must link it to an already existing container control. By doing so, you split the area of the existing control either vertically or horizontally into two new areas, as was done to create the screen in Figure 1. You can then link application controls to the new areas. You can also nest splitter controls to create more areas.

Application Controls

After creating objects of container controls, you can create objects of application controls - the components you want to use onscreen. You must link each application control to an object of a container control. You can do this by simply passing the respective reference to the parameter parent of the application control's constructor. Important application controls and their respective global classes are:

CL_GUI_ALV_GRID: This control allows you to display interactive lists. (ALV stands for ABAP List Viewer, which replaces classical list processing.)
CL_GUI_HTML_VIEWER: This control allows you to display HTML documents. For example, the new help viewer of the ABAP keyword documentation uses an HTML control.
CL_GUI_PICTURE: This control allows you to display any given picture on an R/3 screen. For example, the airplane in Figure 1 is displayed in a picture control. SAP Easy Access is another example of a picture control as background.
CL_GUI_SIMPLE_TREE: This control allows you to display and work with a tree structure. In addition to the simple tree, there are also other kinds of trees available. For example, the Object Navigator of the ABAP Workbench uses a tree control.
CL_GUI_TEXTEDIT: This control implements a full-fledged editor for viewing and maintaining texts. For example, the ABAP Editor uses a textedit control.

Control Methods

You use the methods defined in the control's classes to work with the controls displayed on the screen. In general, you work with the methods of the application controls. You would use these, for example, to fill text from an internal table into the text editor of the textedit control. But sometimes you will also call methods of the CFW. In order to minimize the network load between backend and frontend, method calls are buffered in an automation queue before being sent to the frontend at defined synchronization points, such as at the end of PBO (Process Before Output) processing. To force a synchronization point in your program, you can call the static method cl_gui_cfw=> flush.

Control Events and Event Handling

User actions on controls can trigger events. However, the events of controls are not classical screen events, which trigger the PAI processing at the application server and send a function code. Instead, they are declared as ABAP Objects events in their global wrapper classes. For performance reasons, a user action on controls is not automatically passed back to the application server. If you want an event to be passed back to the application server, you must register it in your program using the special method set_registered_events, which is available in all application controls. You can specify two kinds of event handling:

System Events (default): The event is passed to the application server, but does not trigger the PAI event (see Figure 3). In order to react on the event, you must register an event handler method in your ABAP program with the SET HANDLER statement. This method is then executed on the application server.

Pros and cons: The benefits of using this default technique is that the event handler method is executed automatically. There also are no conflicts with the classical automatic input checks associated with the screen. The disadvantage is that the contents of the classical screen fields that might exist alongside controls are not automatically transported to the program.

TIP: If you work with classical screen fields and you really need to transport their contents during control event handling, you can call the static method cl_gui_cfw=>set_new_ok_code to set a function code and trigger the PAI event, including a field transport. After PAI has been processed, the PBO event of the next screen is triggered (see Figure 3).

Figure 3

Handling of System Events

Application Events: With this second type of event handling, the event is passed to the application server and triggers the PAI (see Figure 4). If you want to handle the event, you must include a method call for cl_gui_cfw=>dispatch in an appropriate PAI dialog module. The dispatch method calls all event handler methods that are defined and registered with the SET HANDLER statement for that event. After the event handler has been processed, control returns to the PAI module and PAI processing continues.

Pros and cons: The advantage of using this method is that you can specify the point at which the event is handled. The contents of the screen fields are also transported to the application server beforehand. The disadvantage is that this kind of event handling can lead to conflicts with the automatic input checks on the screen, which can cause events to be lost.

Why two types of event handling? You have these options because controls may be displayed on classical ABAP screens, and there may be classical screen elements alongside controls. The flexibility of the two types of event registration and the methods of the CFW, mentioned above, allow you to steer the sequence of data transports between frontend and backend. If you do not use any classical screen components at all, you can simply work with system events (the default mode).

Figure 4 Handling of Application Events

Introduction to the Demonstration Program

Our demonstration program is designed to be as simple as possible. It is meant to demonstrate the basic concepts of programming with GUI controls. Because of this, we omitted all superfluous code, and we did not exploit all the possibilities that control technology provides. With the information we provide in this article, you can go on to modify the program to learn more. You can find the code in our example at DEMO_ABAP_ OBJECTS_SPLIT_SCREEN in R/3 Release 4.6C or higher.

Program Structure

Figure 5 shows the processing blocks of the demonstration program. The program contains two local classes, screen_init and screen_handler, which are used to create and fill the controls and to react on the user's input. Since controls are displayed on classical ABAP screens, we need a small classical framework to call a carrier screen for our controls. We use the event block LOAD-OF-PROGRAM and two dialog modules for that purpose.

Listing 1 shows the coding structure of the program. For our demonstration program, we have chosen the program type 1 (executable). Note that we could have taken one of the other program types that support screens, namely a module pool or a function pool. Choosing an executable just simplifies the program execution, because you can start the program directly from the ABAP Editor.

The program does not contain any global data declarations, and it does not make use of the classical reporting events such as START-OF-SELECTION. It is simply a container for the three processing blocks of the classical screen framework, shown in Figure 5, and our two local classes.

Figure 5

Structure of the Demonstration Program

PROGRAM demo_abap_objects_split_screen.
* Classes   ***************************************************
CLASS screen_init DEFINITION CREATE PRIVATE.
...
ENDCLASS.
CLASS screen_handler DEFINITION.
...
ENDCLASS.
CLASS screen_init IMPLEMENTATION.
...
ENDCLASS.
CLASS screen_handler IMPLEMENTATION.
...
ENDCLASS.
* Classical processing blocks ********************************
LOAD-OF-PROGRAM.
...
MODULE status_0100 OUTPUT.
...
ENDMODULE.
MODULE cancel INPUT.
...
ENDMODULE.

Listing 1

Layout of the Demonstration Program

The Program at Runtime

Figure 6 shows which objects the program uses to create the screen display of the demonstration program, along with the references between these objects.

During screen display, there is no instance of the local class screen_init because there is no global reference variable in the program that can point to such an instance. An object of screen_init will be created temporarily during each PBO processing of the screen, where it is used as a factory object to create the control objects from the global classes cl_gui_splitter_container, cl_gui_picture, and cl_gui_ simple_tree. After each PBO processing, the object of screen_init will be deleted by the garbage collector. The objects of the global classes are kept alive by pointers from the CFW because they are bound to screen areas. An instance of screen_handler is registered as an event handler for events of object cl_gui_simple_tree. This instance itself holds references to objects of the global classes cl_gui_ html_viewer and cl_gui_alv_grid. The instances of the global classes are linked to controls on the screen via the CFW layer. The two objects of cl_gui_ splitter_container split the screen in the three areas shown in Figure 1. The objects of the application controls are linked to these areas. The objects of cl_gui_html_viewer and cl_gui_alv_grid are both linked to the same area.

Figure 6

Runtime Objects of the Demonstration Program

Demonstration Program in Detail

The following sections explain the definitions and the processing blocks of the demonstration program in detail. (Again, the code shown here is available at DEMO_ABAP_OBJECTS_SPLIT_ SCREEN in Release 4.6C or higher.)

Classical Screen Framework

Listing 2 shows the complete coding of the three classical processing blocks listed in Figure 5. The ABAP runtime environment raises the event LOAD-OF-PROGRAM at the moment when the program is started. The respective processing block does nothing but call Screen 100. Screen 100 is created with the Screen Painter. In its screen flow logic, the two dialog modules status_0100 and cancel are called during PBO and PAI respectively, the latter with the addition AT EXIT-COMMAND. We did not use the graphical Screen Painter for our example because we have no classical elements on our screen, and we will use an implicit method to create a custom control. The PBO module sets a GUI status. Within that status, the three function codes BACK, EXIT, and CANCEL are defined with function type E (Exit Command) and are activated in the symbol bar. Therefore, the PAI module is called only when the user wants to leave the program. The most important action during PBO is calling the static method init_screen of class screen_handler. All actual screen handling is encapsulated in the two local classes.

   LOAD-OF-PROGRAM.
CALL SCREEN 100.

MODULE status_0100 OUTPUT.
SET PF-STATUS 'SCREEN_100'.
SET TITLEBAR 'TIT_100'.
CALL METHOD screen_init=>init_screen.
ENDMODULE.

MODULE cancel INPUT.
LEAVE PROGRAM.
ENDMODULE.

Listing 2

Classical Processing Blocks of the Demonstration Program

Local Class Definitions

Listing 3 shows the declaration parts of the two local classes of the program: screen_init and screen_handler. In each of the declaration parts, two visibility sections are defined by using the statements PUBLIC SECTION and PRIVATE SECTION. Only those class components that must be used from the outside client are declared in the public sections. All other components are encapsulated in the private sections. All attributes are reference variables that refer to global classes of the CFW. Each local class has an instance constructor and private methods that are used to fill the controls with data.

In addition to these general features, our two local classes also have their own particular features:

Class screen_init has a public static method, init_screen, that can be called without creating an object of that class.
Class screen_handler has an event handler method handle_node_ double_click that can handle events of the global class cl_gui_ simple_tree.

Note the addition CREATE PRIVATE in the definition of screen_init in Listing 3. Objects of class screen_ init can be created only within class screen_init itself.

   CLASS screen_init DEFINITION CREATE PRIVATE.
PUBLIC SECTION.
CLASS-METHODS init_screen.
METHODS constructor.
PRIVATE SECTION.
DATA: splitter_h TYPE REF TO cl_gui_splitter_container,
      splitter_v TYPE REF TO cl_gui_splitter_container,
      picture TYPE REF TO cl_gui_picture,
      tree TYPE REF TO cl_gui_simple_tree.
METHODS: fill_tree, fill_picture.
ENDCLASS.


CLASS screen_handler DEFINITION. PUBLIC SECTION.
METHODS: constructor IMPORTING container
          TYPE REF TO cl_gui_container,
       handle_node_double_click
          FOR EVENT node_double_click
          OF cl_gui_simple_tree
          IMPORTING node_key.
PRIVATE SECTION.
DATA: html_viewer TYPE REF TO cl_gui_html_viewer,
    list_viewer TYPE REF TO cl_gui_alv_grid.
METHODS: fill_html IMPORTING carrid TYPE spfli-carrid,
       fill_list IMPORTING carrid TYPE spfli-carrid
                           connid TYPE spfli-connid.
ENDCLASS.

Listing 3

Declaration Parts of the Two Local Classes

Static Method init_screen

Listing 4 shows the static method init_screen of class screen_init. The single purpose of method init_screen is to create a temporary object of class screen_init. This is done by using a local reference variable, screen. During the CREATE OBJECT statement, the instance constructor of screen_init is executed. Note that after leaving method init_screen, the reference variable screen is deleted. The object is not referenced anymore and will be deleted by the next turn of the garbage collector.

   METHOD init_screen.
DATA screen TYPE REF TO screen_init.
CREATE OBJECT screen.
ENDMETHOD.

Listing 4

The Static Method init_screen of Class screen_init

Instance Constructor of screen_init

Listing 5 shows the instance constructor of class screen_init. The instance constructor is used to create all the container controls on Screen 100 and two of the application controls (picture and tree). Furthermore, it creates an event handler for events of the tree control. Most of the data objects that are needed for this purpose are declared locally within the constructor. The reference variables of type cl_gui_ container can contain references that point to any container control at the screen.

METHOD constructor.
DATA: events TYPE cntl_simple_events,
event LIKE LINE OF events,
event_handler TYPE REF TO screen_handler,
container_left TYPE REF TO cl_gui_container,
container_right TYPE REF TO cl_gui_container,
container_top TYPE REF TO cl_gui_container,
container_bottom TYPE REF TO cl_gui_container.
CREATE OBJECT splitter_h
EXPORTING
parent = cl_gui_container=>screen0
rows = 1
columns = 2.
CALL METHOD splitter_h->set_border
EXPORTING border = cl_gui_cfw=>false.
CALL METHOD splitter_h->set_column_mode
EXPORTING mode = splitter_h->mode_absolute.
CALL METHOD splitter_h->set_column_width
EXPORTING id = 1
width = 110.
container_left = splitter_h->get_container( row = 1 column = 1 ).
container_right = splitter_h->get_container( row = 1 column = 2 ).
CREATE OBJECT splitter_v
EXPORTING
parent = container_left
rows = 2
columns = 1.
CALL METHOD splitter_v->set_border
EXPORTING border = cl_gui_cfw=>false.
CALL METHOD splitter_v->set_row_mode
EXPORTING mode = splitter_v->mode_absolute.
CALL METHOD splitter_v->set_row_height
EXPORTING id = 1
height = 160.
container_top = splitter_v->get_container( row = 1 column = 1 ).
container_bottom = splitter_v->get_container( row = 2 column = 1 ).
CREATE OBJECT picture
EXPORTING parent = container_top.
CREATE OBJECT tree
EXPORTING parent = container_bottom
node_selection_mode =
cl_gui_simple_tree=>node_sel_mode_single.
CREATE OBJECT event_handler
EXPORTING container = container_right.
event-eventid = cl_gui_simple_tree=>eventid_node_double_click.
event-appl_event = ' '.
APPEND event TO events.
CALL METHOD tree->set_registered_events
EXPORTING events = events.
SET HANDLER event_handler->handle_node_double_click FOR tree.
CALL METHOD: me->fill_picture,
me->fill_tree.
ENDMETHOD.

Listing 5

The Instance Constructor of Class screen_init

Creating the Container Controls

The code in Listing 5 demonstrates the process involved in creating the container controls in the demonstration program:

Create the first splitter container (CREATE OBJECT splitter_h). The constructor creates an object of the global class cl_gui_splitter_ container using the reference variable splitter_h. In the CREATE statement, actual parameters are passed to the IMPORTING parameters of the global class's constructor.

Create a Custom Control at Screen 100 (parent = cl_gui_container =>screen0). By passing the static attribute screen0 of class cl_gui_ container to the parameter parent, we use the entire area of Screen 100 as a custom control implicitly. (This is why we didn't have to use the graphical Screen Painter for Screen 100 to create a custom control.)

Alternatively, we could create a custom control on Screen 100 with the graphical Screen Painter and pass its name instead of screen0. Then, only this area would be used for displaying the controls.

TIP: When you write more complex programs that work with more than one screen, you must create custom controls with the graphical Screen Painter in order to distinguish between the screens.

Split the screen into two columns (columns = 2). We fill the remaining IMPORTING parameters with appropriate values to split Screen 100 into two columns. For each column, a new container control is created. References to each new container are stored in a system table of the CFW. You cannot access this table from the ABAP program. Nevertheless, the table lines point to container control objects of the program that are currently linked to a screen and prevent these objects from being deleted by the garbage collector, even if the container control objects are not referenced in the program itself (see Figure 6).

TIP: To remove a control object from the program, you must use its method free before initializing all respective reference variables. This method deletes the respective entry from the CFW system table.

Get references of the two columns into container_left and container_right. After we set some attributes of the columns by calling methods of splitter_h, we read the references to our containers from the CFW into the local reference variables container_left and container_right by functional calls of method get_container.
Create two rows in the left column (CREATE OBJECT splitter_v). We follow the basic principles of steps 1-4 in a similar procedure to split the left column into two rows. Here, we pass the reference in container_left to the constructor of cl_gui_splitter_ container and get references of the two new container objects into the local reference variables container_ top and container_bottom.

Creating the Application Controls By going through the steps listed above, we have created all the container controls that we need. Now we can go on to create our application controls. The process is shown in the code in Listing 5, and involves these steps:

Create application controls for the left column (CREATE OBJECT picture and CREATE OBJECT tree). With the instance constructor of class screen_init, we create the two application controls for the containers in the left column. In the upper container, we create an object of cl_gui_picture. In the lower container, we create an object of cl_gui_simple_tree. We link the objects to the respective container controls by passing the references in container_top and container_ bottom to their constructor's IMPORTING parameter parent.
Create an event handler (CREATE OBJECT event_handler). Since we want our program to react on user actions in the tree control, we must provide and register an event handler:
- First, we create an object of our local class screen_handler.
- The constructor of this class demands an IMPORTING parameter of type cl_gui_container. We pass the reference to the right column's container control.
- In order to register our object of class screen_handler as an event handler for the tree control, we must call the special method set_registered_events as well as the simple SET HANDLER statement (see "Control Events and Event Handling" above).
- The parameters are passed via an internal table of type cntl_ simple_events, which is defined in the ABAP Dictionary.
- By moving a blank character ' ' (default value) and not an 'X' to the component appl_event, we define that the event is handled as a system event (default) and not as an application event.
Send initial data to the application controls (call method: me->fill picture, me->fill tree). Finally, the constructor calls the methods fill_picture and fill_tree to initialize the contents of our application controls on the screen.

Method fill_picture

Listing 6 shows the instance method fill_picture of class screen_init. The method fill_picture imports a picture in GIF format from an indx type database table abtree into a local internal table pict_tab. The function module dp_create_url creates a URL for that internal table and passes it to the local variable url. By passing that URL to method load_picture_from_url of our picture control object, we send the picture to the picture control at the screen. The method set_display_mode allows us to set the attributes of the picture displayed in the control.

Instead of working with an internal table, you can also use a local picture file from your presentation server and pass its name directly to the parameter url of method load_picture_from_url. Our program has the advantage of working for all users.

 METHOD fill_picture.
TYPES pict_line(256) TYPE c.
DATA pict_tab TYPE TABLE OF pict_line.
DATA url(255) TYPE c.
IMPORT pict_tab = pict_tab FROM DATABASE abtree(pi) ID 'FLIGHTS'.
CALL FUNCTION 'DP_CREATE_URL'
EXPORTING
 type = 'IMAGE'
 subtype = 'GIF'
TABLES
data = pict_tab
CHANGING
 url = url.
CALL METHOD picture->load_picture_from_url EXPORTING url = url.
CALL METHOD picture->set_display_mode
EXPORTING display_mode = picture->display_mode_fit_center.
ENDMETHOD.

Listing 6

The Instance Method fill_picture of Class screen_init

TIP:How can you save pictures in an indx type database table? Listing 7 shows a little helper routine that fulfills that purpose. Provide your favorite picture in a folder (for example, C:\TEMP\ of your presentation server) and simply run this program. The program loads the picture in binary format into an internal table and exports it to an indx type database table. (We strongly recommend that you create your own indx type table instead of using abtree or indx itself!)

 REPORT picture_save.
PARAMETERS file TYPE rlgrap-filename DEFAULT 'C:\TEMP\.GIF'.
PARAMETERS id(20) TYPE c.
DATA pict_line(256) TYPE c.
DATA pict_tab LIKE TABLE OF pict_line.
CALL FUNCTION 'WS_UPLOAD'
EXPORTING
 filename = file
 filetype = 'BIN'
TABLES
 data_tab = pict_tab.
EXPORT pict_tab = pict_tab TO DATABASE abtree(pi) ID id.

Listing 7

Helper Routine to Save GIFs in a Database Table

Method fill_tree

Listing 8 shows the instance method fill_tree of class screen_init. To create a tree-like structure within the tree control, you must call method add_nodes and pass an internal table of special structure and contents to that method. The addition TYPE TABLE OF in the declaration of node_table in Listing 8 shows that the line type of that internal table is abdemonode, defined in the ABAP Dictionary. You can create such types by copying the global template structure mtreesnode.

The internal table contains one line for each node of the tree. Each node must have a unique key node_key. The columns relatkey and relatship describe the relations between the nodes. You can also add description texts, change the standard icons, and so on. In our example, we create a node table from the contents of database table spfli. The database table spfli is the well-known table of flight connections from SAP's training and demonstration flight model.

We select all data from spfli into the sorted internal table spfli_tab and process this table in a loop. There, we fill the internal table node_table with lines that represent a tree structure of two hierarchy levels. The attributes of the nodes are set by assigning flags to some columns of node_table. Note that we replace the standard folder icon with an airplane icon for the subnodes by assigning the internal code "@AV@" to the image columns.

 METHOD fill_tree.
DATA: node_table TYPE TABLE OF abdemonode,
node TYPE abdemonode,
spfli_wa TYPE spfli,
spfli_tab TYPE SORTED TABLE OF spfli
WITH UNIQUE KEY carrid connid.
SELECT carrid connid
FROM spfli
INTO CORRESPONDING FIELDS OF TABLE spfli_tab.
node-hidden = ' '.
node-disabled = ' '.
node-isfolder = 'X'.
node-expander = ' '.
LOOP AT spfli_tab INTO spfli_wa.
AT NEW carrid.
node-node_key = spfli_wa-carrid.
CLEAR node-relatkey.
CLEAR node-relatship.
node-text = spfli_wa-carrid.
node-n_image = ' '.
node-exp_image = ' '.
APPEND node TO node_table.
ENDAT.
AT NEW connid.
CONCATENATE spfli_wa-carrid spfli_wa-connid
  INTO node-node_key.
node-relatkey = spfli_wa-carrid.
node-relatship = cl_gui_simple_tree=>relat_last_child.
node-text = spfli_wa-connid.
node-n_image = '@AV@'.
node-exp_image = '@AV@'.
ENDAT.
APPEND node TO node_table.
ENDLOOP.
CALL METHOD tree->add_nodes
EXPORTING table_structure_name = 'ABDEMONODE'
node_table = node_table.
ENDMETHOD.

Listing 8

The Instance Method fill_tree of Class screen_init

TIP: To find the internal codes of all SAP icons, execute the report SHOWICON.

Instance Constructor of screen_handler

Listing 9 shows the instance constructor of class screen_handler. The instance constructor of class screen_init creates an object of class screen_ handler. This means that the execution of the instance constructor of class screen_handler is embedded in the execution of the instance constructor of class screen_init. It creates two application control objects, both of which are linked to the right column of our vertical splitter control. Remember that the instance constructor of class screen_init passes the reference to the right column's container control and to the constructor's parameter container in the CREATE OBJECT statement. The application controls can display either HTML pages or lists, but they are not filled during the constructor's execution yet. Filling these controls depends on the user's action in the tree control.

 METHOD constructor.
CREATE OBJECT: html_viewer EXPORTING parent = container,
list_viewer EXPORTING i_parent = container.
ENDMETHOD.

Listing 9

The Instance Constructor of Class screen_handler

Method handle_node_double_click

Listing 10 shows the instance method handle_node_double_click of class screen_handler. This method is declared and registered as an event handler for the event node_double_click of our tree control object. Therefore, each time a user double-clicks on a node of the tree, it triggers that method. The method imports the event's EXPORTING parameter node_key, which contains the key of the selected node. Depending on the key's contents, the event handler either calls method fill_html or fill_list. It also sets the visibility of the two application controls referenced by html_viewer and list_viewer. Remember that both controls are linked to the right column of our vertical splitter control. The event handler steers their alternative display in that container.

As stated above, method calls to the frontend are buffered in an automation queue. But since there is no automatic synchronization point after handling a system event on the backend, we must force the system to process the preceding method calls. To do this, we must call the static method cl_gui_cfw=>flush. Note that we do not have any regular PAI processing in our program except when the user leaves the screen. The communication between frontend and backend is handled by the CFW. The frontend-to-backend communication is triggered by events, and the backend-to-frontend communication is triggered by flushes.

 METHOD handle_node_double_click.
DATA: carrid TYPE spfli-carrid,
connid TYPE spfli-connid.
carrid = node_key(2).
connid = node_key+2(4).
IF connid IS INITIAL.
CALL METHOD: fill_html EXPORTING carrid = carrid,
html_viewer->set_visible EXPORTING visible = 'X',
list_viewer->set_visible EXPORTING visible = ' '.
ELSE.
CALL METHOD: fill_list EXPORTING carrid = carrid
connid = connid,
list_viewer->set_visible EXPORTING visible = 'X',
html_viewer->set_visible EXPORTING visible = ' '.
ENDIF.
CALL METHOD cl_gui_cfw=>flush.
ENDMETHOD.

Listing 10

The Instance Method handle_node_double_click of Class screen_handler

Method fill_html

Listing 11 shows the instance method fill_html of class screen_handler. When a user selects a node, this method reads the value of column URL from the database table SCARR according to the node selected. The selected URL is simply passed to the method show_url of our HTML control, which displays it in its area on the screen.

Beginning with Release 4.6C, the new column URL of the carrier database table SCARR will contain the addresses of the carrier's Web sites. To add, change, or update the addresses, you can provide your own data and change the program accordingly.

 METHOD fill_html.
DATA url TYPE scarr-url.
SELECT SINGLE url
FROM   scarr
INTO   url
WHERE  carrid = carrid.
CALL METHOD html_viewer->show_url EXPORTING url = url.
ENDMETHOD.

Listing 11

The Instance Method fill_html of Class screen_handler

Method fill_list

Listing 12 shows the instance method fill_list of class screen_handler. This method gives you an impression of how to work with the new SAP List Viewer, which will replace classical ABAP list processing. As with the tree control, you have to prepare data in an internal table and pass this table to a method of the List Viewer object. In our case, we read detail information from database table sflight into an internal table flight_tab when the user has double-clicked a flight connection in the tree. In addition to the actual data, we prepare and pass additional information - such as the list's title and some of its attributes - to the method. Figure 7 shows the screen after selecting a flight connection in the tree.

 METHOD fill_list.
DATA: flight_tab TYPE TABLE OF demofli,
BEGIN OF flight_title,
 carrname TYPE scarr-carrname,
 cityfrom TYPE spfli-cityfrom,
 cityto TYPE spfli-cityto,
END OF flight_title,
list_layout TYPE lvc_s_layo.
SELECT SINGLE c~carrname p~cityfrom p~cityto
INTO  CORRESPONDING FIELDS OF flight_title
FROM  ( scarr AS c
  INNER JOIN spfli AS p ON c~carrid = p~carrid )
WHERE p~carrid = carrid AND
 p~connid = connid.
SELECT fldate seatsmax seatsocc
INTO  CORRESPONDING FIELDS OF TABLE flight_tab
FROM  sflight
WHERE carrid = carrid AND connid = connid
ORDER BY fldate.
CONCATENATE flight_title-carrname
connid
flight_title-cityfrom
flight_title-cityto
INTO list_layout-grid_title
SEPARATED BY space.
list_layout-smalltitle = 'X'.
list_layout-cwidth_opt = 'X'.
list_layout-no_toolbar = 'X'.
CALL METHOD list_viewer->set_table_for_first_display
EXPORTING i_structure_name = 'DEMOFLI'
is_layout = list_layout
CHANGING  it_outtab = flight_tab.
ENDMETHOD.

Listing 12

The Instance Method fill_list of Class screen_handler

Figure 7

List Display with an ALV Control

Conclusion

In this article, we showed you the principal concepts of programming screens with the control framework using a detailed demonstration program. This procedure can be condensed into the following steps:

Create container control objects and link them to areas at the screen.
Create application control objects and link them to the container controls.
Provide data for the controls in data objects, which, in most cases, are internal tables of special global types.
Send the data to the controls by calling control methods.
React on user actions on the controls by defining and registering event handler methods.

In this article, we did not explain the single control classes - or their methods and events - in great detail. We simply wanted to provide an overview for the ABAP Objects programmer who wants to use global classes of the CFW and who defines his or her own local classes to handle the control objects on the screen.

Using this article as a starting point, you can learn more about the features of the control framework by referring to the documentation of the control classes or to their definition in the class builder of the ABAP Workbench. With that information, you can then continue to explore the CFW on your own. For example, you might create classes that react when a user clicks on a picture. Or you could look further into tree controls, so that when a user selects a node in a tree control, you could introduce context menus for those nodes. Users would then find these when they right-click on a particular node. Finally, there is much to discover about the ALV, which we covered only briefly. ALV is the best choice for presenting tabular data on the screen. It replaces classical table controls as well as classical lists, and it provides a complete environment for interactive reporting.

If you wish to design and improve GUI features that benefit your users, the opportunities are there, and the development process for these interfaces is more streamlined than ever before. Whichever features you choose to take advantage of, this article can be your springboard to creating an interface that is an effective tool for your end users.

Horst Keller is information developer in the SAP ABAP & GUI Group. He documents the ABAP language with an emphasis on ABAP Objects. He also develops and teaches classes on ABAP programming and gives workshops at technical education conferences. You can reach him at horst.keller@sap.com.

Gisbert Loff is product manager in the SAP ABAP & GUI Group, where he handles all GUI-related issues. He has given various lecture presentations and workshops at technical education conferences and SAPPHIREs. You can reach him at gisbert.loff@sap.com.

Get instance of ALV after calling REUSE_ALV_GRID_DISPLAY

2008-11-05T01:19:00.000-08:00

At work I met the scenario like this.

I often use Function Module (FM) REUSE_ALV_GRID_DISPLAY to display an ALV list (usually the fastest way). However, the problem came to me when I needed to reload the data inside ALV control. Normally, you would think that just re-calling the FM to gain the goal. But, this way would create another screen and it is not satisfied my aim.

After searching a while in the alv object (ABAP OO). I fould that the class has the instance level method refresh_table_display that would help me out for the situation. From that clue, the only thing that I need is the current instance of ALV object already created by the first FM call.

Thanks to internet and some one's wisdom, the way is just appear in front of me.

Here is how:
* you need the filed symbol ref to class alv.

FIELD-SYMBOLS: <fs_alv> TYPE REF TO cl_gui_alv_grid.
ASSIGN ('(SAPLSLVC_FULLSCREEN)GT_GRID-GRID') TO <fs_alv> .

*If the sy-subrc equal 0, this means that you just got an instance and freely to manipulate it.

IF sy-subrc = 0.
CALL METHOD <fs_alv>->refresh_table_display().
ENDIF.

P.S: after the release of R/3 4.7 , Object Oriented Programming model is fully implemented. Feel free to work with OOP.

My ABAP life

Blag's best blogs picks from 2009

Blag's best blogs picks from 2008

Ten golden rules that help me every day

Troubleshooting Your ABAP Programs Using Coverage Analyzer

ZahackBusiness CardCompany: YASH TechnologiesPosted on Aug. 31, 2009 12:28 AM in ABAP

Ways of Testing ABAP programs

Viquar IqbalBusiness CardCompany: Yash TechnologiesPosted on Sep. 02, 2009 03:59 AM in ABAP, Beginner, ERP

Nomen est Omen - ABAP Naming Conventions

Uwe SchiefersteinBusiness CardCompany: Lindt & Spruengli (Schweiz) AGPosted on Aug. 31, 2009 12:33 AM in ABAP, Standards

Sending E-Mail from ABAP - Version 610 and Higher - BCS Interface

Sending E-Mail from ABAP - Version 610 and Higher - BCS InterfaceThomas Jung Business CardCompany: SAP Labs, LLCPosted on Sep. 08, 2004 03:13 AM in ABAP, Application Server

Basic ABAP OO eLearnings

Basic ABAP OO eLearningsThomas Jung Business CardCompany: SAP Labs, LLCPosted on Aug. 11, 2009 06:29 AM in ABAP, Beginner, Business Server Pages, Web Dynpro

Introduction

Part 1 - Basics

Part 2 - Classes, Inheritance, Visibility, Polymorphism

Part 3 - Persistant Objects

Part 4 - User Interface

Part 5 - Putting It All Together

Source Code

SAP IDES ECC 5+ Demo flight Data Generation

FM Parsing Select option for displaying in ALV header

BAPI for Details of Sales Order

User Exits & BADIs

ABAP Objects in Action: Screen Programming with the Control Framework

ABAP Objects in Action: Screen Programming with the Control Framework

Get instance of ALV after calling REUSE_ALV_GRID_DISPLAY

Zahack
Business Card
Company: YASH Technologies
Posted on Aug. 31, 2009 12:28 AM in ABAP

Viquar Iqbal
Business Card
Company: Yash Technologies
Posted on Sep. 02, 2009 03:59 AM in ABAP, Beginner, ERP

Uwe Schieferstein
Business Card
Company: Lindt & Spruengli (Schweiz) AG
Posted on Aug. 31, 2009 12:33 AM in ABAP, Standards

Sending E-Mail from ABAP - Version 610 and Higher - BCS Interface
Thomas Jung
Business Card
Company: SAP Labs, LLC
Posted on Sep. 08, 2004 03:13 AM in ABAP, Application Server

Basic ABAP OO eLearnings
Thomas Jung
Business Card
Company: SAP Labs, LLC
Posted on Aug. 11, 2009 06:29 AM in ABAP, Beginner, Business Server Pages, Web Dynpro