SAP Library - SAP NetWeaver Composition Environment Library

SAP NetWeaver Composition Environment Library

Introduction

Guidelines

What's New in SAP NetWeaver Composition Environment 7.1

What's New in SAP NetWeaver CE 7.1 SP3

Release Notes for AS Java

Wizard-Based Configuration (New)

Activating a Configuration Template (New)

Logging: Standalone Log Viewer (Enhanced)

Logging: Creating Log Controllers (Enhanced)

Logging: log-configuration.xml File (Deleted)

Administration Using Telnet (Changed)

Server-side Development Infrastructure Client (New)

Reliability Improvements in JMS (New)

Java Web Dynpro (Enhanced)

User Interface for SAP NetWeaver Scheduler for Java (New)

Web Services (New)

Services Registry (Enhanced)

Introduction of WTP 2.0 and Eclipse 3.3 in Java EE Tools (New)

Release Notes for Composition Tools

Composite Application Framework

Knowledge Management Integration (New)

CAF and Business Intelligence Integration (New)

Bidirectional Associations (New)

Implementing Web Services in CAF (New)

Publishing Web Services in Service Registry with CAF (New)

Guided Procedures

Additional Callable Object Types (New)

Callable Objects Features (Enhanced)

Copy Wizard (Changed)

Parameter Configuration and Consolidation (Enhanced)

Design Time and Runtime Worksets (Enhanced)

Administration Workset (Enhanced)

Visual Composer

Visual Composer Features (New)

Visual Composer Features (Enhanced)

Visual Composer Features (Changed)

BI Data Services (New)

Voice

Internationalization of Voice Applications (New)

SAP Text Application Gateway (New)

Portal Content Modeling

Modeling Portal Content with Visual Composer (New)

Portal

Implementing a Federated Portal Network (Enhanced)

Permission Editor Includes GPAL (Enhanced)

Portal Content Studio (Enhanced)

Property Editor (Enhanced)

Role Editor and Workset Editor (Enhanced)

Universal Worklist

Release Notes for Adobe Document Services

What's New in SAP NetWeaver CE 7.1 SP4

What's New in SAP NetWeaver CE 7.1 SP5

What's New in SAP NetWeaver CE 7.1 SP6

What's New in SAP NetWeaver CE 7.1 SP7

What's New in SAP NetWeaver CE 7.1 SP8

What's New in SAP NetWeaver CE 7.1 SP9

What's New in SAP NetWeaver CE 7.1 SP10

What's New in SAP NetWeaver CE 7.1 SP11

What's New in SAP NetWeaver CE 7.1 SP12

What's New in SAP NetWeaver CE 7.1 SP13

What's New in SAP NetWeaver CE 7.1 SP14

What#s New in SAP NetWeaver CE 7.1 SP 17

Release Notes for AS Java

Administrator’s Guide

Architecture of AS Java

Configuration of SAP NetWeaver CE

Administration of SAP NetWeaver CE

SAP NetWeaver CE Security Guide

Developer’s Guide

Introduction to the SAP NetWeaver Developer Studio

Starting the Developer Studio

Setting Workspace Using the -data Parameter

Setting the Java VM Using the -vm Parameter

Changing the Default Workspace

Starting the Developer Studio Using a Batch File

Using Other Start Parameters

Update Manager

Viewing the Error Log File

Workbench Basics

Welcome Page

Available Perspectives

Basic Preferences

SAP Preferences

Working with the Developer Studio

SAP's Component Model

Creating and Modifying Projects

Referencing Libraries

Testing Java Applications

JLin

Creating and Editing Variants

Executing Tests

Results

J2EE Tests with JLin

Testing Web Dynpro Applications

Test Scripts and Test Results

Recording a Test Script in the Developer Studio

Replaying a Test Script in the Developer Studio

Comparing Scripts and Results

Guidelines for Developing Composite Applications

Guiding Principles for Designing Composite Applications

SAP Composite Forms by Adobe

Business Logic and Abstraction Layer

Composite Application Framework

Back-End Connectivity Layer

Developing and Composing Applications

Modeling Composite Views with Visual Composer

Getting Started

Visual Composer Architecture

Prerequisites

Accessing Visual Composer

Introducing the Storyboard Desktop

Typical Workflow

Creating a Model

Locating the Data Services

Designing the Component Logic and Flow

Designing the User Interface

Deploying the Model

Concepts

Quick Start Tutorial

Creating the Basic Model

Adding a Second Data Service

Creating an Entry List

Creating a Wizard

Adding a Popup

Defining a Dynamic Expression

Tasks

Working with Models

Planning a Model

Creating a Model and Development Component

Opening a Model

Saving a Model

Saving a Copy of a Model

Working with Source Control

Adding a Development Component to Source Control

Checking In a Model

Checking Out a Model

Reverting to the Last Checked-In Version of a Model

Synchronizing a Model

Designing the Composite View

Discovering Data Services

Modeling Composite Views Using BI Data Services

Structure of a BI Data Service

Reusing Components

Composing the Composite View

Introducing the Compose Task Panel

Connecting Model Elements

Redefining Ports

Configuring the Composite View

Defining Data

Mapping Data

Laying Out the UI

Defining Layout Options

Adding Controls

Controls Overview

Adding Controls in a Melting Group

Working with Dynamic Expressions

Dynamic Expression Editor Dialog Box

Messages in the Dynamic Expression Editor Dialog Box

Defining Dynamic Expressions

Frequently-Used Functions

Performing Advanced Modeling Tasks

Finding and Modifying References

Storing Data in a Data Store

Creating a Multi-Selection Table

Defining Popups

Creating Service Components

Creating a Service Using the Service Component Wizard

Defining Validation Rules

Managing System Aliases

Preparing Models for Translation

Modeling Composite Views for Use in Guided Procedures

Transferring Data Using a Data Bridge

Creating an Error Report

Compiling and Deploying Models

Viewing Log Files

Visual Composer Reference Guide

Main Workspace Elements

Configuration Dialog Boxes

Options Pane

Options Pane - Model Group

Options Pane - Design Group

Options Pane - Performance Group

Options Pane - Compiler Group

Options Pane - Embedded Support Group

View Runtime Configuration Dialog Box

Manage System Aliases Dialog Box

Model Menu Dialog Boxes

Create New Model Dialog Box

Open Model Dialog Box

Save As Local Copy Dialog Box

Manage Models Dialog Box

Create New Development Component Dialog Box

Add to DTR Details Dialog Box

Activity Description Dialog Box

Import Dialog Box

Export Dialog Box

Task Panels

Get Started Task Panel

Compose Model Task Panel

Compose Model Task Panel (Design Board)

Compose Model Task Panel (Layout Board)

Configure <Element> Task Panel

Configure Button Task Panel

Configure Calendar Task Panel

Configure Chart View Task Panel

Configure Checkbox Task Panel

Configure Combo Box Task Panel

Configure Composite View Task Panel

Configure <Connecting Line> Task Panel

Configure <Connector> Task Panel

Configure Data Service Task Panel

Configure Date Picker Task Panel

Configure Dropdown List Task Panel

Configure Form View Task Panel

Configure Horizontal Separator Task Panel

Configure Hyperlink Task Panel

Configure Image Task Panel

Configure Input Field Task Panel

Configure Layer Task Panel

Configure Nested View Task Panel

Configure Note Task Panel

Configure <Operator> Task Panel

Configure Panel Task Panel

Configure Plain Text Task Panel

Configure Popup Task Panel

Configure Progress Bar Task Panel

Configure Radio Group Task Panel

Configure Service Component Task Panel

Configure Table View Task Panel

Configure Tabstrip Task Panel

Configure Text Editor Task Panel

Configure Toggle Button Task Panel

Configure Vertical Separator Task Panel

Configure View Switch Task Panel

Configure Window Task Panel

Configure Wizard Task Panel

Search Task Panel

Select Classifications Dialog Box

Deploy Task Panel

View Dialog Boxes

Customize Column Widths Dialog Box

Edit Data Series Dialog Box

Edit Title Dialog Box

Select Event Dialog Box

Control Dialog Boxes

Define Action Dialog Box

Edit Entry List Dialog Box

Entry List Wizard

Entry List Wizard: Select Entry List Type

Entry List Wizard: Define List Items

Entry List Wizard: Select Data Service

Entry List Wizard: Configure Input

Entry List Wizard: Configure Output

Validation Rules Dialog Box

Operator Dialog Boxes

Define Aggregate Dialog Box

Define Distinct Dialog Box

Define Filter Dialog Box

Define Sort Dialog Box

Define Switch Dialog Box

Define Union Dialog Box

Service Component Wizard

Service Component Wizard: Define Service Name

Service Component Wizard: Define Data

Service Component Wizard: Define Input

Service Component Wizard: Define Conditions

Data Dialog Boxes

Define Data Dialog Box

Initialize Data Dialog Box

Map Data Dialog Box

Redefine Ports Dialog Box

Test Data Service Dialog Box

Expression Dialog Boxes

Dynamic Expression Editor Dialog Box

Find All Expressions Dialog Box

Find Element References Dialog Box

Find Field References Dialog Box

Designing Composite Processes with Guided Procedures

Getting Started

Setting Up Portal Roles

Getting Started with Guided Procedures Design Time

Launching Guided Procedures (GP) Design Time

Gallery

Managing Folders and Objects in the Gallery

Copying GP Content

Object Design Time

Getting Started with Guided Procedures Runtime

Getting Familiar with the GP Runtime

Core Elements of the Runtime

Getting Familiar with the GP Runtime Work Center

GP Generic Views

Getting Familiar with the Process Instance Work Center

Process Instance Generic Views

Other Elements

Concepts

Guided Procedures Architecture Overview

Process Roles

Callable Object

Callable Object Parameters

Process Modeling

Tasks

Exposing Applications as Callable Objects

Creating Callable Objects in the GP Design Time

Exposing Web Dynpros as Callable Objects

Creating Web Dynpro Form Callable Objects

Exposing WD4VC Applications as Callable Objects

Exposing Web Services as Callable Objects

Exposing RFCs as Callable Objects

Exposing BSPs as Callable Objects

Creating Portal Callable Objects

Exposing Web Pages as Callable Objects

Creating Callable Objects for Background Execution

Creating Business Logic Callable Objects

Creating Content Packages

Creating Decision Dialogs

Creating Object Views

Creating Pass Through Form Callable Objects

Predefined Callable Objects

Testing Callable Objects

Checking Callable Object Consistency

Modeling and Configuring Workflows

Action Design

Creating Actions

Attaching Callable Objects

Ad-Hoc Items

Customizing Titles of Tasks

Block Design

Creating Blocks

Defining Block Flow

Configuring Exception Handling

Parallel Dynamic Block

Process Design

Creating Process Templates

Defining Process Flow

Configuring Process Roles

Defining Restrictions

Defining Runtime Views

Configuring Process Control Items

Composite Forms

Configuring Process Instantiation

Searching in the Parameter List

Configuring Parameters

Consolidating Parameters

Consolidating Roles

Granting Permissions

Granting View Permissions

Defining and Configuring Notifications

Attachments

Info Callable Objects

Integrating Offline and Form-Based Activities

Concepts of the Composite Forms in Guided Procedures

Guided Procedures Forms Use Types

Form Context

Logical Criteria

Creating and Configuring Forms

Enabling Form Submission Using HTTP

Enabling Form Submission Using SMTP

Creating Logical Criteria

Creating Form Objects in the GP Design Time

Building and Using Form Context

Enabling Form Input Validation

Configuring Post-Processing Services

Adding Content to Field-Based Templates

Adding Content to Schema-Based Templates

Configuring Form Use and Data Processing Options

Designing Dynamic Forms

Exposing Composite Forms as Callable Objects

Using a Display Callable Object for Forms

Instantiating and Testing Guided Procedure Forms

Activating and Maintaining Guided Procedures Content

Activating Guided Procedures Content

Comparing and Restoring Object Versions

Customizing and Updating SAP Content

Transporting GP Content Using NWDI

Starting and Terminating Processes Within a Composite

Starting (Initiating) a New Process

Granting Substitution Permissions

Consuming the GPProcessDiscovery Web Services

Starting a Process Using Web Services

Completing Actions Within a Composite

Consuming the GPActionDiscoveryWSIL Web Service

Completing a Step Using Web Services

Using the GP APIs

Setting Up Your Project

Implementing and Registering Callable Object Types

Implementing the Design Time for a New Callable Object Type

Implementing the Runtime for a New Callable Object Type

Registering a New Callable Object Type

Implementing Additional Callable Objects

Implementing Web Dynpro Callable Objects

Implementing Callable Objects for Background Execution

Implementing BSP Callable Objects

Modeling and Configuring Workflows Using the GP API

Instantiating the Design Time Manager

Creating GP Development Objects

Creating Callable Objects

Implementing Exception Handling

Implementing Parameter Mapping

Defining Activity Mappings

Defining Callable Object Mappings

Implementing Role Consolidation

Editing GP Development Objects

Deleting GP Development Objects

Exposing Business Object Data in the GP Context

Constructing a KM Document Template and Provider

Including Additional Functionality

Using the Forms API

Accessing the Forms Java API

Retrieving Process Template Details

Creating Form Instances

Creating Custom Runtime Views Using the GP API

Runtime View Component Interfaces

Interface Methods for Component Initialization

Registering Web Dynpro Components and Runtime Views

Registering Runtime Views Using Servlets

Scheduling Process Initiation Using the GP API

Implementing a Post-Processing Class with Callback

Starting and Terminating Processes Using the GP API

Completing Actions Using the GP API

Managing Process Notifications Using the GP API

Retrieving Process Notification Instances

Updating Notification Processing Time and Status

Creating Deadlines and Durations

Managing Runtime Attachments Using the GP API

Attachment Attributes

Reference

Tutorials

Developing Your First Process

Creating a Folder

Creating an HTML Start Page

Creating an Input Data Form

Setting Up Mail Templates

Replacements

Creating an Approval Callable Object

Creating a Simple Process

Initiating a Process

Exposing an RFC-Enabled Function Module as a Callable Object

Configuring an RFC Destination

Importing a BAPI in Guided Procedures

Testing and Activating an RFC Callable Object

Importing a Web Service in Guided Procedures

Testing and Activating a Web Service Callable Object

Developing Your First Composite Form Process

Modeling the Composite Form Activity

Configuring Pre-Filling Services

Creating the Composite Form

Designing the Form Template Layout

Exposing the Composite Form as a Callable Object

Modeling the Form Approval Activity

Modeling the Notification Activity

Creating Notification E-Mail Templates

Designing the Process Template

Implementing and Exposing a Web Dynpro as a Callable Object

Creating and Configuring the Web Dynpro Project

Implementing a Web Dynpro Component

Creating an Instance of the Callable Object

Testing and Activating the Callable Object

Implementing and Exposing a Background Callable Object

Creating a Java Development Component

Implementing a Background Callable Object

UserDetailsCallableObject

Creating and Deploying a Java Enterprise Application

Exposing a Java Class as a Callable Object

Testing and Activating the Background Callable Object

Configuring Exception Handling

Creating a Data Input Form

Creating an Action to Handle the Exception

Creating a Data Display Form

Creating an Exception Block

Creating an Exception Process

Implementing a BSP Callable Object

Sample BSP Application

Creating a Start Page

Creating a Completion Page

Creating an Instance of a BSP Callable Object

Scenario: Order Office Material

Web Dynpro Component Implementation

WDCODisplaySelectItems

WDCOSelectedItems

WDCOOrderItems

WDCOApproveItems

Defining Fine-Grained Process Components

Decision List or Order Number

Display List and Select

Decision Order Another Item

Display Selected Items

Order Items

Approve Items

Send Order Confirmation

Order Confirmation

E-Catalog

Defining Blocks

Display List and Select Loop Body

Display List and Select Loop

Order with Order Number

Order From List

Order Office Material

Process Definition: Putting It All Together

Composing Services with CAF

Getting Started

Opening the Composite Application Perspective

Developing Your First Business Object

Creating a New Application

Modeling Business Objects

Defining Business Objects Operations

Generating Code and Building Services

Developing Your First Application Service

Creating an Application Service

Creating Application Service Operations

Implementing Application Service Operations

Developing Your First Permission Checks Implementation

Implementing Permission Checks for Business Objects

Testing Permission Checks for Business Objects

Configuring Authorizations for Business Objects

Consuming ES Workplace Web Services in CAF

Importing the Web Service

Creating and Modifying the Application Service

Testing the Application Service

Composite Application Development Components

Tasks

Creating Composite Application Development Components

Creating and Editing Data Types

Securing Your Composite Application

Protecting Access to Application Service Operations

Protecting Access to Business Object Operations

Managing the Business Rules List

Managing the Access Control List

Managing the Conditions List

Modeling Business Objects

Creating Business Objects

Modeling Business Object Attributes

Modeling Service Operations

Defining Business Object Persistency

Defining Business Object Associations

Exposing Application Services or Business Objects as Web Service

Locking Business Objects

Implementation Example for Locking Business Objects

Modeling Application Services

Creating Application Services

Modeling Service Operations

Defining Application Service Dependencies

Filtering Business Object Instances in Application Service

Exposing Application Services or Business Objects as Web Service

Modeling External Services

Importing RFC Modules

Importing Web Services

Editing External Services

Exposing Application Services or Business Objects as Web Service

Mapping Service Operations

Rules for Service Mapping

Configuring External Services in CAF Runtime

Implementing Web Services in CAF

Publishing Web Services in Service Registry with CAF

Developing with CAF in Team-Oriented Environment

Resolving Conflicts in CAF

Testing Services with the Service Browser

XSD Data Types Mapping

Transporting CAF Content Between Different Composites

Integrating KM Documents in CAF

Configuring CAF for Knowledge Management Integration

Configuring Connectivity to Knowledge Management

Configuring UME Policies and Authentication Templates

Configuring CAF Repository Managers

Configuring CAF Runtime Properties

Configuring CAF Security and Repository Managers

Adjusting the URL Generator Service

Configuring CAF Repository Managers for Troubleshooting

Adjusting Mime Handler Service Properties

Cleaning Temporary Documents in KM

Creating and Reading a KM Document from CAF Services

Locking and Unlocking a KM Document

Versioning a KM Document

Integrating CAF Services in Composite Views and Processes

CAF and Business Intelligence Integration

DataSource Use in CAF and SAP BI Integration

DataSource Name Restrictions

DataSources to Access Business Object Node Attributes

DataSources for Language-Dependent Attributes

DataSources for Business Object Associations

DataSources for BI Extractor Operations

Configuring CAF for SAP BI Integration

Data Extraction in CAF and SAP BI Integration

Example of Data Extraction

Extractor Methods in CAF and SAP BI Integration

Extractor Method Implementation Example

Reference

Composite Application Explorer

Icons Used in the Composite Application Explorer

Composite Application Perspective Tab Pages

General Tab Page

Associations Tab Page

Implementation Tab Page

Predefined Services and Data Types

Supported Web Service Structures and Facets

Developing User Interfaces with Web Dynpro for Java

Getting Started

Developing Your First Web Dynpro Application

Plugs and Navigation Links

Data Binding and Mapping

Event

Action

Interfaces of Web Dynpro Components

Web Dynpro Application

Web Dynpro Model

Tasks

Choosing the Client

Integrating WD Applications into SAP NetWeaver Portal

Web Dynpro Client for Windows

Defining a Link to a Web Dynpro Application

URL of the Web Dynpro Application

Client-Side URL Parameters

Launching Web Dynpro Applications in the Windows Client

Functions of the Top-Level Toolbar

Mobile Web Dynpro Online

UI Elements for Mobile Web Dynpro Applications

Specifics of Nokia Series 80 and 60 Devices

Specifics of BlackBerry Wireless Handhelds

Specifics of Pocket PCs

Mobile Add-On Library

BarCodeReader

Using the BarCodeReader

FunctionKey

Using the FunctionKey

RFIDReader

Using the RFIDReader

Setting Up the Web Dynpro Project

Web Dynpro Development Component (DC)

Web Dynpro Project

Creating a Web Dynpro DC

Creating a WD Project

Migrating Web Dynpro Projects into the NWDI

Repairing Projects

Integrating Services

Importing Enterprise Services Models

Adjusting Port Matches

Maintaining Object and Interface References

Web Dynpro as Provider for Role-Based Access Management

Using Business Objects from the Enterprise Services Framework

Importing Adaptive Web Service Models

Adaptive Web Service Model

Web Service Invocation Object

Destination Service (Enhanced)

Migrating to the Adaptive Web Service Model Type

Importing Enterprise JavaBean (EJB) Models

Enterprise JavaBean (EJB) Model

Importing Adaptive Remote Function Call (RFC) Models

Defining Adaptive RFC Models

Invalidating Metadata Caches

Importing JavaBean Models for DC Projects

Importing JavaBean Models for Local Projects

Using JavaBean Logic for WD

Retrieving Bean Classes from .jar Files

Retrieving Bean Classes from Source Directories

Conditions and Naming Conventions for Import Beans

Editing Model Classes

Specifying Components

Creating Components

Implementing Components with Their Controllers and Interfaces

Implementing Component Controllers

Implementing View Controllers

Implementing Window Controllers

Controller Concept

Controller Class and Interface Reference

Controller Interface Concept

Adding Custom Controllers

Wrapping Services in Controllers

Adding Model References

Adding Windows

Defining Window Properties

Defining Views

Creating Layout Views

Applying View Templates

Creating Buttons, Events, and Plugs

Creating Tables With Direct Controller Access

Creating Forms Using Context Data

Checking View Design

Defining User Messages

Navigation Modeling

Creating Plugs

Navigating Between WD Java Applications and Other Web Applicatio

Suspend and Resume Plug

Creating Navigation Links

Defining Controllers

Defining Controller Relations

Creating Actions

Handling Events

Mapping Event Parameters to Action Parameters

Mapping the Generic Event Parameter nodeElement

Implementing Parameter Mapping

Creating Context Trees Manually

Specifying Dataflow

Binding Context to the Model

Data Binding

Bindable Data Types

Binding UI Element Properties to Dictionary Types

Bringing Files To Context

Binding Tables

Binding Trees

Designing View Layouts

Choosing the Layout

Adding UI Elements

Programming UI Dynamically

Methods of the UI Element APIs

Creating Mobile Web Dynpro Online Applications

UI Elements for Mobile Web Dynpro Applications

Specifying Common UI Element Properties

Specifying the Image Source

Displaying and Formatting Core Data Types

Internationalizing Applications

Sequence of Language Display

Getting Language-Specific Resources

Translating UI Strings

Running Web Dynpro Applications

Creating Applications

Configuring the Web Dynpro Runtime Environment

Configuring Applications

Deploying Applications

Starting Applications

Adding WD-Specific Parameters to URL

Stopping Applications

Ensuring Quality

Debugging Applications

Enabling Servers for Debugging

Debugging Contexts

Testing Web Dynpro Applications

Checking Monitoring Availability

Minimizing Byte Code

Web Dynpro Class File Minimizer

Reference

Controller Class and Interface Reference

Common Controller Class Reference

Common Controller Interface Reference

Component Controller Class Reference

Component Controller Interface Reference

Custom Controller Class Reference

Custom Controller Interface Reference

View Controller Class Reference

View Controller Interface Reference

Window Controller Class Reference

Window Controller Interface Reference

UI Element Guide

Specifying Common UI Element Properties

WDTableCellDesign

Specifying the Image Source

Choosing the Layout

ColumnLayout

ColumnLayoutData and ColumnLayoutHeadData

MatrixData and MatrixHeadData

RowLayout API

RowData and RowHeadData

BIApplicationFrame: Integrating BEx Web Applications

BIMethods API: Access to Actions of a BEx Web Application

Breadcrumb Navigation

BreadCrumb

BreadCrumbStep

MultipleBreadCrumbStep API

HierarchicalCalendarMonthView

DateNavigatorLegend API

DropDownByIndex

DropDownByKey

Explanation

FileUpload and FileDownload: Data Transfer

FileUpload

FileDownload

Binding resource Property

Loading the InputStream at FileDownload on Demand

Displaying and Editing Formatted Text

Supported XHTML Tags for FormattedText

FormattedTextEdit

FormattedTextView

SimpleFormattedTextField

Implementing a SimpleFormattedTextField

Creating Formatted Text

Gantt

GeoMap

Code Example of the Use of a Geographical Map

Example for Displaying a Route

Implementing a Combo Box

Enabling AutoComplete for InputFields

MultipleLegendItem API

Implementing Menus: ContextMenu, MenuBar and PopupMenu

Utilizing ContextMenus

Implementing IWDIOSFactory

HorizontalContextualPanel

PatternExpandFunction

RadioButtonGroupByKey

RadioButtonGroupByIndex

Filtering and Sorting in a Table

Adding New Rows

TableColumnGroup API

TableColumn API

TableScrollTipProvider

TableRowGrouping API

Implementing TableRowGrouping

TreeByNestingTableColumn API

Cell Variants

TableStandardCell API

TableSingleMarkableCell API

Defining Cell Variants

TablePopin API

TablePopinToggleCell API

ToolBarDropDownByIndex

ToolBarDropDownByKey API

Data Binding of a Tree UI Element

Code Example for Creation of a Tree UI Element

Controller/Context Editor

Data Modeler

Java Editor

Message Editor

Metadata Comparison Tool for WD Projects

Metadata Comparison Tool

Web Dynpro Metamodel Object Search

Navigation Modeler

View Designer

Web Dynpro Explorer

SAP Interactive Forms By Adobe for Web Dynpro

Adobe Library

InteractiveForm API

Web Dynpro Form UI Element CheckFields

Web Dynpro Form UI Element EnumeratedDropDownList

Web Dynpro Form UI Element EnumeratedDropDownListNoSelect

Web Dynpro Form UI Element HideReaderToolbar

Web Dynpro Form UI Element SubmitToSAP

Web Dynpro Form UI Element ValueHelpDropDownList

Example of the Use of an Interactive PDF Form

Setting Up Basic Authentication in a Java Environment

Tutorials

Integrating EJB 3.0 into Web Dynpro Using the EJB Model Importer

Creating an EJB Development Component (DC)

Developing the Business Logic

Creating an Enterprise Application DC

Preparing DC’s for Use by Other Components

Developing a Web Dynpro Client Application

Setting Up the Web Dynpro DC Project

Creating the EJB Model

Creating the Context

Specifying the View Layout and the Data Binding

Adding Java Code for the Controller

Deploying and Running the Sample Application

Using Service Classes

Deployment Service

Configuration Service

Internationalization Service

URL Generation Service

User Management Service

Logging Tracing Service

Tips and Tricks

Hiding default messages in the problem list

Providing Documentation for Developers

Naming Rules to Ensure Personalization

Problem Analysis: All Web Dynpro Applications Have Status STOPPE

Problem Analysis: Application Ends With Runtime Exception Error

Problem Analysis: Deployed Web Dynpro Application Does Not Run

Developing Java EE 5 Applications

Getting Started

Configuring the Application Server in the Developer Studio

Developing Your First Java EE 5 Application

Developing the EJB 3.0 Module

Developing the Web Module

Deploying and Running the Enterprise Application

Concepts

Java EE 5 Development Tools

Java EE Perspective

JPA Development Perspective

Deploy Perspective

Java Enterprise Edition 5 Overview

Java Persistent Entities

Web Services

JavaServer Faces

Application Server's Robustness and High Availability

Tasks

Developing Persistence

Overview of the Java Persistence Infrastructure

Using JPA in the Persistence Layer

Creating Connections to the Java Dictionary

Creating Database Connections

Creating JPA Projects in the Developer Studio

Creating Entities and Generating Database Tables

Generating Primary Keys

Creating Database Tables and Generating Entities

Working with the Entity Manager

Obtaining an Entity Manager Instance

Managing Entity Instances

Creating and Executing Queries

Configuring the Persistence Unit in the persistence.xml

Running JPA Applications on the System DataSource

Versioning with read_uncommitted Isolation Level

Developing Persistence Using Open SQL/JDBC

Getting a Connection to the Database

Inserting Data Into a Table

Using Queries

Semantics of the Data Types DATE, TIME, and TIMESTAMP

Transactions in Open SQL/JDBC

Native SQL Access

Error Handling

Using Open SQL for Java Features

Table Buffer

Buffer Granularity

Statements Using the Buffer

Statements Bypassing the Buffer

Modifications and Actions on the Remote Buffers

Buffering Hints

Open SQL Monitors

Managing the SQL Trace

Evaluating SQL Traces

Connection Monitor

Catalog Buffer Monitor

Table Buffer Monitor

Sync Log Monitor

Table Statistics Monitor

Open SQL Statistics

Native DB Monitors

Open SQL Data Browser

Reading and Writing LOBs En Bloc

Handling Transactions and Resources in Applications

Introduction to Transactions in AS Java

JTA Implementation

JTS Implementation

JTA and Local Transactions

Using Container-Managed JTA Transactions

Using Component-Managed JTA Transactions

Using Local Transactions

Two-Phase Commit

Resource Handling Mechanism

Connection Handling in JTA and Local Transactions

Sharing Connections

Database Connection Management

Developing Business Logic with EJB 3.0

EJB Overview

Creating EJB 3.0 Projects in the Developer Studio

Creating Session Beans in the Developer Studio

Setting a Session Timeout

Creating Message-Driven Beans in the Developer Studio

Setting the MDB Properties in the ejb-j2ee-engine.xml

Using Dependency Injection

Specifying Transaction Attributes

Specifying Security

Using Interceptors and Life Cycle Callbacks

Using Java Persistence API (JPA)

Using Enterprise JavaBeans as Web Service Endpoints

Editing the ejb-j2ee-engine.xml

Accessing Enterprise JavaBeans from Remote Clients

Using Timers

Developing User Interfaces

Creating Dynamic Web Projects

Using Annotations in Web Applications

Annotations in Web Applications

Injecting EJB Resources into Web Applications

Injecting Resources into Web Applications

Accessing Persistence in Web Applications

Configuring Methods Using Annotations in Web Applications

Configuring Security Roles Using Annotations in Web Applications

Developing JavaServer Faces (JSF) Web Applications

Creating the JSF UI Components

Creating JSF JSP Files

Standard JSF Tags

Dynamic Data Tables

Command Buttons

Validating User Input

Managed Beans

faces-config.xml

Developing Servlets

Creating Servlets in the Developer Studio

Initializing Servlets

Servicing Client Requests

Retrieving Client Input

Retrieving Multipart Request Messages

Request Attributes When Using Application Zones

Obtaining the Remote Host Address

Composing HTTP Responses

HTTP Response over Persistent Connections

IOException in Cases When Client Closes Connection

Threadsafe Servlets

Handling Cookies in Servlets

Setting Cookies in HTTP Servlets

Retrieving Cookies from the HTTP Request

AS Java Cookies

Servlet-defined Cookies

HTTP Sessions

Lifetime of a Session

Session Tracking with Servlets

Accessing and Manipulating the Session Object

Terminating a Session

URL Rewriting as an Alternative to Cookies

HTTP Sessions and Failover of Web Applications

Dispatching Requests to Web Application Resources

Including Requests

Forwarding Requests

Destroying Servlet Instances

Developing Event Listeners

Developing JSP Pages

Creating JSP Files in the Developer Studio

JSP Life Cycle

Syntax Elements Outline

Using the page Directive

Implicit Objects

Standard Actions

Including and Forwarding Requests in a JSP

JSTL

Developing Custom Tags

Developing Classic Tag Handlers

Developing Simple Tag Handlers

Developing TLD Files

Describing Tag Handlers in TLD Files

Developing Tag Files

Describing Tag Files in TLD Files

Unified Expression Language

EL Expressions in Tag Attribute Values

Deferred Expressions Evaluation

Using EL Implicit Objects

Developing EL Functions

Developing Portlets

Portlet Life Cycle

Implementing the Portlet Interface

Extending the GenericPortlet

Initializing Portlets

Servicing Action Requests

Servicing Render Requests

Portlet Preferences

Portlet Sessions

Dispatching Requests to Servlets and JSPs

User Information

Packaging and Deployment Descriptor

Portlet Tag Library

Creating Listeners and Filters

Editing the web-j2ee-engine.xml

Configuring Resource References Using the web-j2ee-engine.xml

Example: Describing Data Sources in the web-j2ee-engine.xml

Example: Describing JMS Connection Factories in the web-j2ee-eng

Creating and Configuring Web Services and Web Service Clients

Providing Web Services

Providing Web Services Inside Out

Creating an Inside-Out Web Service from an Enterprise Java Bean

Creating an Inside-Out Web Service from a Servlet-Based Endpoint

Service Endpoint Interface

Providing Web Services Outside In

Creating Outside-In Web Services

Importing WSDL Documents in the SAP NetWeaver Developer Studio

Browsing Enterprise Services from the SAP NetWeaver Developer St

Global Customizations

Providing a TU&C/C Web Service

Viewing Web Service Artifacts

Restrictions to Web Service Implementation Beans

Consuming Web Services

Creating Web Service Proxies

Creating Web Service Client Applications

Consuming TU&C/C Web Services

Extended Proxy Capabilities

Configuring Web Services at Design Time

Setting an Authentication Level

Setting the Transport Guarantee Level

Configuring a One Way Message Exchange Pattern

Configuring Web Services Reliable Messaging

Configuring Stateful Communication

Configuring Web Services and Web Service Clients in the SAP NetW

Concepts

Configuration of Individual Web Services and Web Service Clients

Configuration of Groups of Web Services

Configuration of Several Web Service Clients

Service Metering

Configuring Web Services

Configuring Individual Web Services

Configuring Groups of Web Services

Preparing the Configuration Settings in Profiles

Grouping and Configuring Web Services in Configuration Scenarios

Editing Configuration Scenarios

Managing WSDL Documents

Accessing Information Provided via WSIL

Configuring Web Service Clients

Configuring Individual Web Service Clients

Creating Web Service Physical Destinations

Testing Web Services in the Web Services Navigator

Finding Web Services

Testing a Web Service Operation

Testing Web Services with Pre-Defined Input Data

Viewing Web Services Logs and Traces

Configuring Proxy Settings

Single Sign-On for Web Services

Publishing Web Services to the Services Registry

Connecting the SAP NetWeaver Developer Studio to the Services Re

Adding Classifications to Web Services

Publishing Web Services from the SAP NetWeaver Administrator

Supported Specifications

Tutorials

Configuring the SAP NetWeaver Developer Studio

Developing a HelloWorld Web Service

Creating the HelloWorld Web Service

Creating an Enterprise Java Bean Project for the HelloWorld Web

Creating the Enterprise Java Bean

Exposing the Enterprise Java Bean as a Web Service

Deploying the HelloWorld Web Service

Testing the HelloWorld Web Service

Creating the HelloWorld Web Service Client

Creating a Dynamic Web Project for the Web Service Client

Importing the WSDL Document

Generating the Web Service Proxy

Creating the Web Service Client Application

Deploying the HelloWorld Web Service Client

Exposing and Configuring the Converter Application as a Web Serv

Exposing the Converter Application as a Web Service

Importing the Converter Application in the SAP NetWeaver Develop

Exposing the Implementation EJB as a Web Service

Setting an Authentication Level to the Web Service

Deploying the Converter Web Service

Configuring the Web Service in the SAP NetWeaver Administrator

Testing the Converter Web Service

Creating the Converter Web Service Client

Creating a Dynamic Web Project for the Converter Web Service Cli

Importing the Converter WSDL Document

Generating the Converter Web Service Proxy

Creating the Converter Web Service Client Application

Deploying the Converter Web Service Client

Configuring the Web Service Client in the SAP NetWeaver Administ

Setting Severity to Web Services and Web Service Clients

Starting the Converter Web Service Client Application

Viewing Converter Web Service and Web Service Client Logs and Tr

Using Java Message Service

JMS Overview

Creating and Configuring JMS Virtual Providers

Creating and Configuring JMS Resources and Resource References

Property Reference

Accessing JMS Resources

Using a Third-Party JMS Provider

Using JMS Store and Forward

Creating Message Producers and Consumers

Using Queue Browsers

Using Durable Subscriptions

Using Message Selectors

Message Selector Syntax

Consuming Messages from Message-Driven Beans

Processing Messages

Handling Dead Messages

Using Transactions

Handling Exceptions

Example

Developing JCA Resource Adapters

Creating Connector Projects in the Developer Studio

Implementing 1.5 Resource Adapter

What's New in JCA 1.5

The Resource Adapter JavaBean

Outbound Communication

Inbound Communication

Message Endpoint Activation

Message Inflow Scenario

Transaction Inflow Support Implementation

Implementing the Work Management Contract

Implementing 1.0 Resource Adapter

Implementing Connection Management

Implementing Transaction Support

Implementing Interaction Functions

Assembling and Configuring the Resource Adapter

Resource Adapter Archive (RAR)

ManagedConnectionFactory Configuration

Resource Adapter Transaction Support

Connection Pooling

Resource Adapter Classloading

Using Resource Adapter to Obtain a Connection

Driving an Interaction with the EIS

Developing Application Clients

Working with Libraries

Creating Standard Libraries

Creating Bundled Libraries

Migrating Old Library Projects

Using Heavy Application Libraries

Heavy Loaders

Assembling Components into Enterprise Applications

Creating Enterprise Application Projects

Adding Modules to the Enterprise Application

Creating Bundled Libraries

Adding the application.xml to Enterprise Application Projects

Editing the application-j2ee-engine.xml

Deploying Applications

Deploying and Undeploying with SAP NetWeaver Developer Studio

Building, Publishing and Removing Published Java EE Applications

Deploying Archives

Working with Deploy Templates

Managing Deployed Archives

Undeploying Archives

Managing Substitution Variables

Viewing Deployment Related Logs

Filtering and Sorting Archives

Deploying Applications with Third-Party Deployment Tools

Using Ant Scripts to Work with SDAs

Using Shell Scripts to Work with SDAs

Managing the Application Environment

Creating Your Own Application Tables in the Database

demotables.sql

Working with Data Sources

Deploying Data Sources

Data Source Example

Deploying Data Source Aliases

Deploying JDBC Drivers

Creating J2EE 1.4 Applications in SAP NetWeaver Developer Studio

Creating J2EE 1.4-Compliant Web Components

Creating EJB 2.1 Components

Assembling J2EE 1.4-Compliant Enterprise Applications

Debugging Java Applications

Starting Remote Debugging

Stopping Remote Debugging

Using AS Java APIs

Using JavaMail

Obtaining a Session Object

Creating E-Mail Messages

Sending E-Mail Messages

Receiving E-Mail Messages

Creating Secure Connections Using JavaMail

HTTP Client

HTTP Client Properties

Simple Get Request to a Specified Host and Port Example

Get Request Using Proxy Example

Posting File Using Chunked Encoding Example

Get Request Using Basic Authentication Example

Managing System and Application Configurations

Configuration Manager

Monitoring Configurations

Java Configuration Browser

Adding Configuration Capabilities to an Application

Connecting As an AS Java Application

Deploying Properties Within an Application

Accessing Application Properties

Registering a Property Change Listener

Modifying Application Properties

Accessing the System Profile

Naming and Directory Services (JNDI)

JNDI Registry Service

Creating an Initial Context

Binding Objects

Looking up Objects

Browsing the Naming Tree

JNDI Browser

NAMING Shell Commands

Using JNDI Registry Service to Locate Resources

RMI-P4

The Distributed Object Model

Characteristics of a Remote Object

RMI-P4 System Overview

Remote Objects Communication in RMI-P4

Garbage Collection of Remote Objects

Load Balancing of Client RMI-P4 Requests

Failover for Clustered RMI-P4 Remote Objects

Network Configuration for RMI-P4

Develop RMI-P4 Applications

Defining a Remote Interface

Implementing the Remote Interface

Binding the Implementation to the Naming System

Generating Stubs and Skeletons

Implementing a Client

Accessing Enterprise JavaBeans from Remote Clients

Using P4 Protocol Over a Secure Connection

Additional P4 Protocol Connection Configuration

RMI-P4 Specific InitialContext Properties

Reference

Deployment Descriptors

appclient-j2ee-engine.xsd

application-j2ee-engine.xsd

connector-j2ee-engine.xsd

ejb-j2ee-engine.xsd

ejb-j2ee-engine_3_0.xsd

data-source-aliases.dtd

Tutorials

Project Management and Employee Services Application

Running the Application

Setting Up Application Users

Running the Predeployed Application

Deploying and Running the Application from NWDS

Application Data Model

Rebuilding the Project Management and Employee Services Applicat

Developing the Persistence Entities

Creating the EDMProjectEJBDemo

Generating the Project Entities

Implementing the Employee Entity

Configuring the Persistence Unit

Developing the Session Beans

Creating the ProjectManagementService Session Bean

Implementing the ProjectManagementService Session Bean

Developing the Message Driven Beans

Creating the ProjectChangeReceiver Bean

Defining the JMS Destination for the Bean

Implementing the ProjectChangeReceiver Bean

Reference

CeraDepartment Source Code

CeraEmployee Source Code

CeraNavigation Source Code

CeraProject Source Code

CeraPrjHistory Source Code

CeraSkill Source Code

CeraUsergroup Source Code

ApplicationResetReceiver Source Code

DataResetService Source Code

DataResetServiceLocal Source Code

EmployeeManagementService Source Code

EmployeeManagementServiceLocal Source Code

ProjectChangeReceiver Source Code

ProjectChangeSender Source Code

ProjectChangeSenderLocal Source Code

ProjectManagementService Source Code

ProjectManagementServiceLocal Source Code

Application Users and User Groups

Developing a Message-Driven Bean Application

Creating an EJB 3.0 Project and an EAR Project

Developing the Message-Driven Bean

Configuring the JMS Resources

Deploying the EAR

Sender JMS Client Example

Running the Example

Developing an Application Client

Creating and Implementing an EJB 3.0 Project

Creating and Implementing the Application Client

Deploying the Application

Running the Application Client

Java Persistence Reference

Overview of the JDBC API

JDBC Java Packages

java.sql

javax.sql

JDBC Java Classes and Interfaces

java.sql.Blob

java.sql.Clob

java.sql.Connection

java.sql.DatabaseMetaData

java.sql.Driver

java.sql.PreparedStatement

java.sql.ResultSet

java.sql.ResultSetMetaData

java.sql.Statement

Open SQL Reference

Open SQL Database Dependencies

Delimited Identifiers

SELECT FOR UPDATE Statement

Value expressions

Column References

Set Functions

Arithmetic Expressions

Dynamic Parameter Specification

Search Condition

Comparison predicate

Scalar Subqueries

Quantified comparison predicate

Data Type Conversion Tables

Mapping JDBC Types to Java Types

Type Conversions Supported by ResultSet Getter Methods

Type Conversions Supported by PreparedStatement Setter Methods

Open SQL Type Propagation

Developing Voice-Enabled Applications

Getting Started

Voice Development FAQ

Using the Visual Composer Voice Kit

Developing Your First Voice Application

Concepts

Voice Application Design

Voice-Application Design Example

Internationalization of Voice Applications

Voice Application Architecture

Voice Componentization

Voice Lifecycle Management

Tasks

Applying a Typical Voice-Development Workflow

Configuring Your Voice Application

Modeling Voice Applications

Creating a Voice-Enabled Application

Modeling the Voice Application Flow

Handling Data Services

Logins and Authentication

Creating BI Reports

Assigning Logic Paths

Managing Events

Managing Variables

Working with Tables

Creating Complex Prompts

Adding Another Language to Voice Applications

Adding Another Language in a Voice Element

Deploying and Debugging Your Voice Application

Debugging Voice Applications

Debugging Voice Applications without a VoiceXML Gateway

Reference

Application Configuration Data

Application Configuration Fields

Application Configuration Defaults

Component Data

Voice Component

Black Service Component

Elements and Other Entities

Context Entity Data

VoiceXML Gateway Drivers

VoiceObjects Application URL Parameters

Voice Glossary

Tips and Tricks

Keyboard Shortcuts

Modeling Portal Content with Visual Composer

Getting Started

Terminology

High-Level Architecture and Workflow

Getting to Know the Working Environment

Quick Start Tutorial: Modeling a Simple Portal Application

Concepts

Lifecycle Management

Object-Based Navigation

Tasks

Modeling Portal Content

Creating Portal Content Objects

Creating Business Suite Content

Reusing Existing Components

Working with Reused Components

Defining OBN Targets

Deploying Modeled Portal Content

Previewing Modeled Content in the Portal

Post-Deployment Information for Portal Administrators

Developing Applications for the Portal

Portal APIs

Accessing the PCD

Overview

How PCD Lookups are Performed

Portal Content Model (PCM)

Working with Semantic Objects

All Semantic Objects

Creating Objects

Looking Up Objects

Getting/Setting Attributes

Adding iViews to a Page

Removing iViews from a Page

Adding Layouts to a Page

Setting the Default Layout for a Page

Layouts

Moving iViews on a Page

Systems

Getting/Setting System Aliases

Getting User Mapping

Getting Aliases for All Systems

Working with Administration (PCM) Objects

Attributes

Getting/Setting Attributes

Permissions

Catalog Node Attributes

Working with PCD Objects

Contexts and Attributes

Delta Links

Permissions

Types of Permissions

Looking Up/Adding/Removing Permissions

Personalization

Removing Personalization

Automating Content Creation with XML

Key Interfaces and Classes

Executing XML Scripts

Results

Code Sample

Developing Handlers

Registering and Unregistering Handlers

Accessing Attributes

Navigating in the Portal

Navigation Helper Service

Methods

Framework Page

Light Framework Page

Special Navigation Features

Creating Navigation iViews

Navigation Tag Library

Types of Tags

Glossary

How to Use the Tag Library

Tag Reference

doNotRecurseNavNodeChildren

ifAnonymousUser

ifHasMoreIterations

ifNavNodeEqualsLaunchedNavNode

ifNavNodeEqualsSelectedNavNode

ifNavNodeHasChildren

ifNavNodeInSelectedPath

ifNavNodeVisualizationType

ifNextRecursionDepthWillDecrease

ifNextRecursionDepthWillIncrease

ifNextRecursionDepthWillNotChange

ifNot ...

iterateInitialNavNodes

iterateNavNodeChildren

iterateNavNodesInSelectedPath

iterateSelectedNavNodesLevel

recurseNavNodeChildren

selectedNavNode

storeNavNode

Samples

Top-Level Navigation iView

Detailed Navigation iView

Framework Tag Library

How to Use the Tag Library

Creating Navigation Connectors

Step 1: Creating a Navigation Connector Node

Step 2: Creating a Navigation Connector

Step 3: Registering the Connector

External Connectors

Creating an External Connector

Adding External Connector Nodes

Redirectors

Triggering Navigation

Managing the Navigation Cache

Object-Based Navigation

Key Classes and Interfaces

Creating an OBN Link

Creating an OBN Link (Web Dynpro)

Creating an OBN Link (Portal Runtime)

Sending Parameters to Navigation Target

Navigating within the Source Role

Creating an OBN Dropdown Menu

Querying OBN

Querying Business Objects

Querying Content with the Analyzer

Portal Web Services

Navigation Web Service

getNavigationTree

getNavigationURLPrefix

getSelectedPathTree

Navigation Data Types

CollectionMapEntry

KeyValueEntry

NavigationCollection

NavigationExternalView

NavigationLink

NavigationNode

NavigationTree

NavigationTreeRequest

NavigationTreeResponse

NavigationURLPrefixRequest

NavigationURLPrefixResponse

SelectedPathTreeRequest

SelectedPathTreeResponse

XML Content and Actions Web Service

createContentByXmlString

Page Web Service

getPage

Page Data Types

AdditionalAttributesProperties

Real-Time Messaging Framework

Overview

Application-to-Client Messaging

Application-to-RTMF-Service Messaging

RTMF Events

Publishing Events

Subscribing to Events with Web Dynpro

Getting Information about RTMF Events

RTMF Services

Creating Services

Registering for Messages Sent to Another Service

Synchronizing Services

Sending Messages to Services

RTMF Messages

Types of Messages

Setting/Getting Parameters

Configuring RTMF

Testing RTMF

Working with Users, Groups and Roles

Developing Web Dynpro Applications for the Portal

Web Dynpro Java in the Portal

Calling Portal Services

Page Service

Adding Dynamic iViews

Printing the iView/Page

Tray Service

Navigating in the Portal

Absolute Navigation

Relative Navigation

Navigating with OBN

Communicating with Other iViews

Subscribing to a Client Event

Firing a Client Event

Creating Personalizable Properties

Naming Rules to Ensure Personalization

Sending URL Parameters to Applications

Enabling Multiple iViews from an Application

Using WorkProtect Mode

Setting the Theme

Web Dynpro ABAP in the Portal

Binding to Portal: Prerequisites

Creating Web Dynpro ABAP iViews

Portal Events

Triggering a Portal Event

Registering and Handling an Event

Portal Navigation

Object-Based Navigation (OBN)

Absolute Navigation

Relative Navigation

Resume Plugs and Portal Navigation

Work Protect Mode

Modifying the Portal Look and Feel

Creating Administration Interfaces (Web Dynpro)

Overview

Creating Admin Studio Instances

XML Script for Admin Studio Configuration

Adding Actions Dynamically

Configuring a Work Unit

Creating Wizards

Wizard Context

Validating General Properties

Creating a Split Road Map

Customizing the Finish Pane

Creating Custom Layouts (Web Dynpro)

Overview

Creating a Web Dynpro Page Layout

Sample Layout (Tab Layout)

Using a Web Dynpro Page Layout

HTML-Business for Java

What is HTMLB?

About the Reference

General

Customer Branding and Style Editor

Style Editor

HTMLB Controls and Style Editor

Error Handling

Error Prevention

Error Handling for Fields

Error Handling in Tables

Accessibility of HTMLB Controls

Layout

General Page Layout Aspects

Layout Hierarchy

From Containers to the Layout Hierarchy

Layout Hierarchy for iViews and Web Applications

Table Overview of the Layout Hierarchy

General Nesting Rules

Spacing Between Grouped Controls

Benefits of Correct Spacing

Spacing in a Tray

Spacing between Primary and Secondary Groups

Spacing between Group Controls with Header and Border

Spacing of Elements in Groups

Arranging Groups

Spacing Soft Groups

Spacing Between Single Controls

Groups of Entry Fields

Check Box Groups

Radio Button Groups

Mixed Form Elements in Vertical Succession

Browser Support & 508

Form Layout

Usage & Type

Browser Support & 508

Grid Layout

Usage & Type

Browser Support & 508

Visible Controls

Breadcrumb

Usage & Type

Browser Support & 508

Button

Usage & Type

Browser Support & 508

Button Row

Chart

Usage & Type

Browser Support & 508

Checkbox

Usage & Type

Browser Support & 508

Date Navigator

Usage & Type

Browser Support & 508

Drag Source

Dropdown List Box

Usage & Type

Browser Support & 508

Drop Target

File Upload

Usage & Type

Browser Support & 508

Group

Usage & Type

Browser Support & 508

Browser Support & 508

Input Field

Usage & Type

Browser Support & 508

Isolated HTML Container

Item List

Usage & Type

Browser Support & 508

Label

Usage & Type

Browser Support & 508

Link

Usage & Type

Browser Support & 508

List Box

Usage & Type

Browser Support & 508

List Box Item

Menu Bar

Message Bar

Nonisolated HTML Container

Progress Indicator

Radio Button

Usage & Type

Browser Support & 508

Browser Support & 508

Tabstrip

Usage & Type

Browser Support & 508

Text Edit

Usage & Type

Browser Support & 508

Text View

Usage & Type

Browser Support & 508

Tool Bar

Tool Bar Button

Tool Bar Dropdown List Box

Browser Support & 508

Event Validation (Client Eventing)

Data Storing & Retrieving in the Portal

Usage & Scopes

Using a Bean with the Taglib

JavaScript API

Examples

Building a JSPDynPage

Creating the JSPDynPage

JSPDynPage Event Handling

Data Exchange between JSPDynPage and JSP

Data Exchange Using a Bean

Data Exchange Using the Session Object

Data Exchange Using the Context Object

Data Exchange Using the Request Object

Connector Framework

Connector Framework Architectural Context

Connector Framework Structure

Interface ICapabilities

Interface IStructure

Interface ConnectionSpec

Connection Interfaces

Metadata Retrieval

Data Access and Method Execution

Functions and Queries

Using Existing Connectors

Workflow for Consuming a Connector

Defining the EIS

Getting the Connection

Running a Function/Query

Handling the Output

Closing the Connection

Using the SAP System Connector

Using the JDBC Connector

Using the Web Service Connector

Data Type Handling by the Web Service Connector

Portal Destination Service

Developing a Connector

Connector Wizard

Installation

Using the Connector Wizard

Packages Created by the Connector Wizard

Connector Deployment

Non-Managed Mode

Deployment Descriptor Example

WorkProtect Feature for EP 6.0

Navigation

Glossary

Client Data Bag

JavaScript Origin Policy

Namespaces

Consuming Enterprise Services

Services Registry

Concepts

Structuring of Services in the Registry

Consuming Services with the Services Registry

UDDI Server and Services Registry

Tasks

Searching & Browsing Service Definitions

Classifying Services

Managing Classification Systems

Configuring the Services Registry

APIs

Providing Java Dictionary Tables and Data Types

Modifying Dictionary Preferences

Editing Table Definitions

Creating Views

Integrating Security Functions

Concepts

Developing Authentication Enhancements on the AS Java

Overview of the Login Process in JAAS

Integration of AS Java and UME Authentication

Using Login Modules to Protect Web Applications

Configuring Authentication

Using the HTTP Callback Classes

SAP Specific HTTP Callbacks

Changing the User Password

Single Sign-on for Web Applications

Security Sessions

Security Aspects for Web Services

Remote Authentication

Propagating Security Principals between Application Containers

Tasks

Developing a Custom Logon Screen

Create and Configure a Login Module

Creating and Implementing the Login Module

Creating a New Java Project

Setting Required Classpaths to Compile the Java Project

Implementing the Login Module Source Code

Exporting the Login Module Class in a JAR File

Creating and Implementing the Configuration File

Preparing the Login Module for Deployment

Creating a New Enterprise Application

Exporting a Deployable EAR File

Adding the JAR File and the Configuration File to the EAR File

Deploying the EAR to the AS Java

Configuring the Login Module on the AS Java

Example Login Module

Using APIs

User Management Engine

User Authentication and Single Sign-On

Authentication

Developing a Custom Logon Screen

User

Role

Group

Searching for Users, Roles and Groups

Access Control List (ACL)

Digital Signatures and Document Encryption API

Interfaces and Classes for Using Digital Signatures and Encrypti

Examples for Using Digital Signatures

Secure Connection Factory API for HTTPS Clients

Interfaces and Classes for Using the Secure Connection Factory

Examples for Using the Secure Connection Factory

Destination Service API

Interfaces and Classes for Using the Destination Service API

Examples for Using the Destination Service API

Virus Scan Provider API

Interfaces and Classes of the Virus Scan Provider API

Example Program for the Virus Scan Provider

Using Common Server Infrastructure APIs

SAP NetWeaver Scheduler for Java

Architecture

Scheduler Job Definition, Job, and Task

Developing and Scheduling Jobs

Job Definition

JobBean Class

Deployment Descriptors

Job Scheduling Through the Scheduler API

Getting a JNDI Reference to the Scheduler API

Scheduling Jobs with Recurrent Start Conditions

Scheduling Jobs with Cron Start Conditions

Example: CronEntry

Excluding Scheduled Job Executions from a Scheduler Task

Reference

Scheduler Job Start Conditions

Scheduler Job Statuses

Job-definition.dtd

Job Parameter

Example: Job Parameters

Jobs Behavior in Irregular Circumstances

Creating and Scheduling Your First Job

Hello Job

Creating the Hello Job Definition

Creating an EJB Project

Creating a Message-Driven Bean

Setting the Build Path

Developing the JobBean Class of the HelloJob

Extending the JobBean Class with Job Parameters

Editing the ejb-j2ee-engine.xml

Creating and Editing the job-definition.xml

Editing the application-j2ee-engine.xml

Deploying the HelloJob

Scheduling the HelloJob

Creating a Scheduler Task for the HelloJob

Scheduling Jobs Using the SAP NetWeaver Scheduler for Java

Working with Jobs

Working with Tasks

Creating a Scheduler Task

Setting Recurring Start Conditions

Setting Cron Start Conditions

Setting Simple Start Conditions

Viewing Job Definitions

Developing Logging-Enabled Applications

Logging Quick Guide

How to Write Log and Trace Messages

Logging

Addressees of Log Messages

How to Use Categories

Types and Content of Log Messages

Severities for Log Messages

Tracing

Addressees of Trace Messages

How to Use Locations

Types and Contents of Trace Messages

Severities for Trace Messages

Coding Recommendations

Enabling Logging for Applications

Identify the Output Source: Location or Category

Enable Output Messages

Message Output with Severity

Program Flow for a Location

The Master Gate

Typical Practice for a Better Style

Hierarchical Destination Inheritance

Relations Between Category and Location

Multi-Threading

Configuration Tool

Calling the Configuration Tool

Syntax and Semantics of the Properties File

Support of Periodic Reloading

Summary Highlights

Tips and Tricks

Administrative Issues

Appendix A: Severity Levels

Appendix B: Classes Hierarchy

Appendix C: Default Behavior of Certain Objects

Enabling Applications with Monitoring

Enabling Standard Application Resources Administration

JMX Service Interface

Architecture

Writing MBeans

Connecting to an MBeanServer

MBean Registration

Access to an MBean

Query MBeans