Creating Composite Applications
Developing Composite Applications with CAF Core
Getting Started
Concept of Composite Application Framework Core
Working with Composite Application Services
Opening the Composite Application Services Perspective
Projects in Composite Application Services
Creating Development Component Projects
Deploying Development Component Projects
Composite Application Services and Data Types
Creating Custom Enumerations
Classification Service
Category Service and Assignment
Classification Application Service Operations
Services and Concepts
Service Types
Entity Services
Application Services
External Services
Service Permissions
Service Permission Types
Implementing Custom Permission Checks
Principal Types
Access Control List
Predefined Permission Access Rights
Service Persistency
Service Operations
Service Runtime
Go and Create
My First Composite Application
My First Entity Service
Creating a Development Component Project
Modeling Entity Services
Defining Entity Service Operations
Generating Code and Building Services
Configuring the Object Editor User Interface
Configuring the Object Selector User Interface
Core Development Tasks
Composite Application Framework Runtime Configurator
Administrative Tools
Authorization Tool
Assigning Authorizations
Managing the Business Rules List
Managing the Access Control List
Managing the Conditions List
Managing Propagated Permissions
Getting a Principal Authorization Report
External Service Configuration
Importing External Services at Runtime
Grouping Imported RFCs at Runtime
Configuring External Services at Runtime
Mapping Operations and Attributes at Runtime
Dynamic Attribute Administration
Entity Services
Queries
Dynamic Attribute Metadata
Simple Types
Subscription Management
Content Transport
Preparing for Content Transport
Transporting CAF Content
User Interface Configuration
Other Tools
Developing User Interfaces in CAF Core
Configurable User Interface Components
Authorization Report
Attachments
Adding Attachments
Attach Image
New Attachment
Classification Assignment
Editing Classification Assignments
Removing Classification Assignments
File Select
Flex Tree
Creating Column Headings
History Log User Interface
Navigation
Object Browser
Object Editor
Object Selector
Property Editor
Reporting
Search Bar
User Assignment
Macros
User Interface Transport
Downloading and Uploading Configuration Files
Transporting Configuration Files
Designing Services in CAF Core
Service Tab Pages
Attributes Tab Page
General Tab Page
Data Source Tab Page
Dependencies Tab Page
Implementation Tab Page
Operations Tab Page
Permissions Tab Page
Persistency Tab Page
Service Modeling
Modeling Entity Services
Creating Entity Services
Modeling Entity Service Attributes
Entity Service Attribute Types
Modeling Entity Service Operations
Locking Entity Services
Implementation Example for Locking Entity Services
Modeling Application Services
Creating Application Services
Adding Application Service Operations
Editing Application Service Operations
Using Query Filter in Application Service
Using Generated External Proxy in Application Service
Modeling External Services
Importing RFC Modules as External Services
Importing Web Services as External Services
Editing External Services
Encapsulating External Services as Entity Services
Encapsulating External Services as Application Services
Handling RFC Exceptions
Deleting Services
Generating Web Services from Application or Entity Services
Transaction Support
Using Single Sign-On for Web Services
Service Mapping
Rules for Service Mapping
Mapping Service Operations
Mapping Service Attributes
Service Protecting
Protecting Access to Entity Service Operations
Protecting Access to Application Service Operations
Service Eventing and Notifications
Framework Events
Java Message Service
Event Data Recording
Event Storage
Notification Service Connection
JMS Deployment Descriptors
Class Structure: Value Object Changed Data
Class Structure: Entity Changed Event
Class Structure: Event Helper
Notification and Subscriptions
Notification and Subscription Framework
Modifying the Web Dynpro Model
Ensuring Quality
Testing Services with the Service Browser
Integration
Integrating CAF Core Services and CAF Guided Procedures
CAF Core and SAP Business Information Warehouse Integration
Locking and Unlocking Services in CAF
Calling the Lock Functional Module
DataSource Use in CAF and SAP BW Integration
DataSource Name Restrictions
DataSources to Access Entity Service Attributes
DataSources to Extract Custom Enumeration Types
DataSources to Extract Web Dynpro Enumeration Types
Mapping RFC Destinations for SAP BW Integration
Data Extraction in CAF and SAP BW Integration
Example of Data Extraction
Extractor Methods in CAF and SAP BW Integration
Extractor Method Implementation Example
Delta Loading in CAF and SAP BW Integration
Delta Load Management Framework Overview
Enabling Delta Load
Initializing Delta Load
Extracting Classification Information
Setting Up DataSources for Category Value Extraction
Setting Up Category Value Extraction on Entity Services
Exporting Classification Hierarchies
Importing Classification Hierarchies
Creating InfoObjects for Classification Extraction
Creating Hierarchies for Classification Extraction
Importing Hierarchies for Classification Extraction
CAF Core and Knowledge Management Integration
CAF Security and Repository Managers
TREX Search and Indexing in CAF Core
Reference
Developing Composite Applications with CAF GP
Getting Involved
Concepts of the Guided Procedures Framework
Guided Procedures Architecture Overview
Callable Object
Callable Object Parameters
Process Modeling
Working with the Development Environment
Getting Started with Guided Procedures Design Time
Launching Guided Procedures (GP) Design Time
Gallery
Managing Folders and Objects in the Gallery
Design Time Tools
Creating a Transport Request
Transporting GP Content Using NWDI
Go and Create
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
Developing Your First Form Process
Checking System Configuration
Designing a Form Template
Example: Simple Adobe Form
Exposing the Interactive Form in Guided Procedures
Enhancing the Approval Callable Object
Enhancing the Application Block Flow
Creating Your First Form Process
Core Development Tasks
Integrating Applications into a Composite
Setting Up Your Project
Exposing Applications as Callable Objects
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
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
Exposing Interactive Forms as Callable Objects
Enabling Form Submission Using HTTP
Enabling Form Submission Using SMTP
Interactive Form Prefilling
Interactive Form Validation
Using a Display Callable Object for Forms
Exposing CAF Core Resources as Callable Objects
Creating Content Packages
Creating Decision Dialogs
Creating Object Views
Predefined Callable Objects
Implementing Additional Callable Objects
Implementing Web Dynpro Callable Objects
Implementing Callable Objects for Background Execution
Implementing BSP Callable Objects
Configuring and Deleting Endpoint Aliases Using the GP API
Endpoint Alias Type Definitions
Modeling and Configuring Workflows Using the GP API
Instantiating the Design Time Manager
Creating GP Development Objects
Creating Callable Objects
Creating Actions
Creating Blocks
Creating Processes
Defining Transitions
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
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
Using the Forms API
Handling Forms in Java
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
Starting and Terminating Processes Within a Composite
Starting and Terminating Processes Using the GP API
Consuming the GPProcessDiscovery Web Services
Starting a Process Using Web Services
Completing Actions Within a Composite
Completing Actions Using the GP API
Consuming the GPActionDiscoveryWSIL Web Service
Completing a Step Using Web Services
Enhancing Composites with Additional Functions
Scheduling Process Initiation Using the GP API
Implementing a Post-Processing Class with Callback
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
Ensuring Quality
Testing Callable Objects
Checking Callable Object Consistency
Integration
Using Third Party
Reference
API Documentation
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
Developing Your First Form Process
Checking System Configuration
Designing a Form Template
Example: Simple Adobe Form
Exposing the Interactive Form in Guided Procedures
Enhancing the Approval Callable Object
Enhancing the Application Block Flow
Creating Your First Form Process
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
Exposing an RFC-Enabled Function Module as a Callable Object
Configuring an Endpoint
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
Modeling Visual Composer iViews for Guided Procedures
Preparing to Use Visual Composer
Creating an iView
Defining Input Parameters and Form Elements
Defining Output Parameters and Result States
Configuring Events
Deploying the iView
Exposing the iView as a Callable Object
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 J2EE Library
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