Component com.sap.portal.appintegrator.sap.Generic 

With the com.sap.portal.appintegrator.sap.Generic component any HTTPbased Web application can be integrated very flexible. For example, parameters can be exchanged and SSO can be performed.

As already mentioned before, the Web application is called directly by the client (isolation level URL). Since the portal does not serve as content proxy, the Web application has to be accessible from the client computer, this means that the firewall has to grant a direct connection from the client browser to the application.

 

Iview/Component Parameters

ApplicationParameter

Defines name-value pair parameters that are passed on to the application.

Example: appParam1=value1&appParam2=value2

Multiple name-value pairs have to be separated with the ampersand character (&).

DebugMode

In debug mode, setting this parameter to true, returns a screen with debugging output before launching the application. false disables debugging mode.

Id

Defines name-value pair parameters that are passed on to the application. It is used as placeholder and can be useful to define settings for delta links and iView templates.

LAF

Defines the theme (look and feel) subset (for example,. ur (unified rendering), controls).

SSO2Template

Defines a template that is used for SSO parameter <Authentication> (if the system defines logon with SAP Logon Tickets). See the Single Sign-on description later in this document for more details.

System

Name of the system alias.

URLTemplate

Defines a template that is processed by the template processor in order to generate the application url. See the Template Processor description later in this document for more details.

.

UserMappingTemplate

Defines a template that is used in SSO parameter <Authentication> when the system defines logon with user mapping. See the Template Processor description later in this document for more details.

RequestMethod

Overwrites the default behaviour for retrieving the request method of the redirect (GET or POST). For SSO with user mapping, the default is "POST". "POST" is also used if the parameter list is longer than 1024 characters.

Remark: In EP SP2 Patch 1 this property has to be added manually to the deployment descriptor of the application.

 

 

Template Processor

The template processor parses a template (for example, URLTemplate for the com.sap.portal.appintegrator.sap.Generic component) and replaces the tag expressions that match the context names, with values stored in contexts.

 

Definitions

Template

A template is a string containing text and tags.

Example: This is a template with a simple <tag>.

Tag

A tag is a variable expression followed by an optional modifier sequence in angle brackets.

Example: Enclose tags always in <angle.brackets>

Tag expression

A tag expression (or variable expression) is a set of variables separated by dots.

Example: <tag.expression.with.multiple.variables>

Context

A context is a data structure that stores name-value pairs, similar to java.util.Hashtable. Contexts can be nested.

Variable

A variable is an identifier that matches entries in the context. If a variable name equals a context entry name, the tag is replaced with the value of the context entry.

Example: <context1.variable1> is replaced with the value of variable1 in context1.

Modifier sequence

A modifier sequence contains one or more modifiers in square brackets separated by blanks. Modifiers are applied to the substitute in the order of the occurrence.

Example: This is a template with <modified.tag[URL_ENCODE UPPERCASE]>

Substitute

A substitute of a tag expression is the result of a processed/substituted tag expression.

Example: <User.Name> is the tag expression and Blair Pascal is the substitute.

 

Use of Templates

Nested contexts are accessed with tag expressions. The variables in the tag expression specify the "path" in the context tree, for example,. <x.y>. If a variable does not match a context, the tag is replaced by an empty string.

Processed tag expressions can be automatically URLEncoded using the URL_ENCODE modifier.

Example:

<this.will.be.Urlencoded[URL_ENCODE]>

 

The slash (/) represents the “escape” character in templates. When you put a slash before an angle bracket it is not treated as tag.

Example:

Find car: Mileage /< 50000 and Year />

 

Template grammar:

template      ::= ( plain | tag )* plain         ::= unreserved* unreserved    ::= ... all characters except the reserved ones tag           ::= "<" tagexpr ">" | "<" tagexpr ( modif_seq)">" tagexpr       ::= simpletagexpr ( "." simpletagexpr )* simpletagexpr ::= alpha alphanum* modif_seq     ::= ( alphanum+ " " )+ alpha         ::= "A" | ... | "Z" | "a" | ... | "z" | "_" alphanum      ::= alpha | "0" | ... | "9" reserved      ::= "<" | ">"

 

Example:

<Protocol>://<HostAddress>:<Port>/some/path?user=<User.Name[UPR_CASE]>&   url= <HomeServer.url[URL_ENCODE UPPERCASE]>   The question mark (?) marks the parameter section in an HTTP/S url.

 

Resolution of Expressions

We have the following expressions:

·        Expressions with Variables

Expressions with variables have the format <x>. They are resolved by a custom provider, the request and the iView profile, in this order, in two iterations. The first iteration looks for the variable name, for example, "x", and the second iteration looks for the default variable name, for example, "x.default".

·        Expressions Using a Context

Expressions using a context, like <x.y>, offer data retrieval from data providers such as the system landscape or user management. With a context, it is possible to access a specific property. This could be necessary to overcome the resolution rules.

Example:

The same property exists in the profile and in the request. In order to access this property from the profile, you have to explicitly access the property with the name <Profile.property>. Accessing it with name <property> only, would return the property from the request. The resolution of expressions can be performed either indirectly or directly:

¡        Directly

If the context is known, an expression like <User.UserID> is resolved directly.

¡        Indirectly

An expression like <System.url> is resolved indirectly since the name for the system is not known. It has to be retrieved from the iView profile first before the system landscape can be accessed.

 

Available Variables

The following variables are available:

·        All properties according to the rules given in iViewParameterName

·        User mapping user. Variable: <MappedUser>

·        User mapping password. Variable: <MappedPassword>

·        Authentication string. Variable: <Authentication>

·        User ID used for accessing applications. Variable: <LogonUserId>

This variable contains the portal user ID if no user mapping is maintained. If user mapping exists the variable contains <MappedUser>.

 

 

Available Contexts

The following contexts are available:

·        Look and Feel Context (LAF)

This context provides the following information:

¡        Current theme. Variable: <LAF.Theme>

¡        Base URL of current theme. Variable: <LAF.BaseUrl>

¡        Full qualified stylesheet url. Variable: <LAF.StylesheetUrl>

·        Portal Component Profile Context (Profile)

This context provides information from the iView profile.

¡        Property name from the iView profile. Variable: <Profile.[id]>

·        Portal Context (Portal)

This context provides the following portal information:

¡        Portal Runtime version. Variable: <Portal.Version>

¡        Root url of portal: <Portal.RootComponent>

·        Request Context (Request)

This context provides the following information from the servlet request:

¡        Language. Variable: <Request.Language>

¡        Locale. Variable: <Request.Locale>

¡        Protocol. Variable: <Request.Protocol>

¡        Server name. Variable: <Request.Server>

¡        Port. Variable: <Request.Port>

¡        Server plus port. Variable: <Request.ServerPort>

¡        SSO2 ticket. Variable: <Request.SSO2Ticket>

¡        Any request parameter. Variable: <Request.[ParameterName]>

·        System Landscape Context (System)

This context provides all the properties of the system landscape. The possible variable names are defined by the system landscape itself:

¡        System property value. Variable: <System.[SystemPropertyName]>

·        User Context (User)

This context provides the following user information:

¡        Accessibility level. Variable: <User.Accessibility>

¡        Logon ID. Variable: <User.LogonUid>

¡        Logon ID. Variable: <User.UserID>

¡        User attribute. Variable: <User.[AttributeName]>

 

 

Available Modifiers

Following modifiers are available:

·        BASE64

Performs base64 encoding.

·        HTML_ESCAPE

Escapes the result so that it can be put in HTML documents.

·        LOWERCASE

Converts all characters to lower case.

·        MD5

Performs MD5 encoding.

·        SAP_BOOL

Converts boolean values to SAP notation (true/1 -> 'X', false/0 -> '').

·        SAP_ITS_NAMESPACE

Replaces '/' with '-' (used for IACs)

·        TRIM

Removes all leading and trailing whitespaces.

·        UPPERCASE

Converts all characters to upper case.

·        URL_DECODE

Performs url decoding

·        URL_ENCODE

Performs url encoding

·        PROCESS_RECURSIVE

Forces recursive resolution of templates. If the result of a template is also a template, another recursive step of template processing is performed.

 

 

Single Sign-On

Component com.sap.portal.appintegrator.sap.Generic allows you to perform a Single Sign-On to HTTP Web applications by including the tag <Authentication> in the URL template. Prerequisite is a system with a system definition that includes the following properties:

·        User mapping type, if user mapping is used.

·        Logon method

The tag <Authentication> returns the result of the <UserMappingTemplate> or the <SSO2Template>.

UserMappingTemplate:

For user mapping you can set the UserMappingTemplate as follows:

¡        Basic authentication

<MappedUser>:<MappedPassword>@

The URLTemplate would then look like this:
http://<Authentication>protectedserver.com/xyz

The parameters user and password are application-specific. They need to be retrieved from, for example, the HTML source code of the logon form. The URLTemplate would then look like this:
http://protectedserver.com/xyz?<Authentication>

¡        HTTP form-based login

user=<MappedUser>&password=<MappedPassword>.

 

SSO2Template:

If you use SAP logon tickets for authentication, you can specify an authentication template in parameter SSO2Template like:

MYSAPSSO2=<Request.SSO2Ticket>