Temenos T24 Media TSDK & Web Services.

doc

TSDK & WEB SERVICES

Application Overview

Temenos T24 Software Development Kit

The TEMENOS T24 (referred to as T24) Software Development Kit (TSDK) provides the
ability to extend your TEMENOS T24 implementation by providing extensive Application
Programming Interfaces (APIs) using industry standard coding languages, specifically
java, with native understanding and presentation of T24 tables and records to the
developer.

The T24 SDK comprises:

• TSDK foundation. Provides the base classes for the manipulation of T24 contracts and
enquiries, as well as invocation of core T24 routines and data access.
• TSDK created classes. TEMENOS supply the full-created classes that represent all
tables from T24. This is refreshed with each release of T24.
• The ability to invoke the TSDK from the T24 server, via EB.API.
• The ability to invoke the TSDK at the web server via the T24 Browser

T24 Web Services

T24 Web Services allows you to create, deploy and manage web services to represent
business processes defined in your T24 implementation. Using the T24 web services
offering, implementations of interfaces are greatly simplified by using self-describing web
services created from and representing the underlying business processes in T24.

The T24 WS offering comprises:

• TWS Foundation is the building blocks for the whole architecture. Mainly, these are
classes that deal with the conversion of a java or c# class to an OFS or OFSML
message, and also the basis for customisation of the created web services.
TWS created classes are web service “code behind” packages that are created from a
specified VERSION or ENQUIRY by the WS.CREATE application within T24.

The T24 web services and SDK offering is available at T24 r5 in java providing support for
the J2EE platform. Support for the Microsoft .NET platform via c# will follow in a later
release.

Page 1 Release T24R05

Temenos T24 Media TSDK & Web Services.doc
Overview of Input and Processing

The T24 Software Development Kit

TSDK Foundation
The TSDK exposes T24 tables, records and methods to the developer. The foundation
classes provide native understanding of contract and enquiry processing. Methods on the
TSDK foundation classes expose functionality in T24 – allowing T24 routines to be invoked
directly from the TSDK – but controlling which core routines can be invoked from the API.
Data access is also provided.

The TSDK foundation classes are supplied with full javadoc documentation, however a
brief overview is provided here. The two main classes provided the TSDK foundation are
the TContract and TEnquiry classes. These represent contracts and enquiries in T24. The
TContract base class from the TSDK foundation is the backbone of the entire contract
processing in both the Development Kit and the web services offering, and is the ultimate
super class for all the contract base generated WS classes, which is to say that all the
generated WS classes inherit from this contract class. The TEnquiry class provides the
same function for enquiry based web services.

The TContract class has methods and properties that are used by the TSDK created
classes and the TWS created classes to represent the underlying business objects from
T24. Each TContract class has an array of TProperty classes - the properties class is
simply a field name, field value pair (that handles multivalues and subvalues).

The TSelection field (name, operand and criteria) class provides the ability to add
selection criteria the TEnquiry class.

TSDK Created Classes

Each release of T24 is shipped with a new set of created classes that represent the
business objects within T24.

The created classes expose every table as a class with corresponding get and set
methods (with full support for multi and sub values). Developers can work with the java
classes themselves – they do not need to know the fields that are defined in the
application – these are exposed as properties on the classes. Here we can see the field
names being exposed for the FOREX table:

Page 2 Release T24R05

Temenos T24 Media TSDK & Web Services.doc

Figure 1 - FOREX field names exposed

And here we can see the corresponding getter methods of the actual properties:

Figure 2 - Getter methods

TSDK for server side APIs

T24 comes with an impressive list of server side API hooks that allow the T24
implementation to be customised. These are defined from the table EB.API, and it is here
that the language, package and class or routine name of the API is defined.

Figure 3 - EB.API

Under the T24 architecture, these server side APIs are invoked at the T24 server under
specified conditions, and normally this is at commit time on a contract.

Page 3 Release T24R05

Temenos T24 Media TSDK & Web Services.doc

Figure 4 - Architecture for T24Server APIs

The server side API may be written in either java or basic. In order for the java routine to
be invoked, it must implement the correct interface – com.temenos.tsdk.T24Connection.
Refer to the javadoc for full details.

TSDK for web server APIs

EB.API is reused to define the web server APIs, by attaching the EB.API record to the
WEB.VAL.RTN field on VERSION. The fields that are used to trigger the web validate API
are defined as having the “WEB.VALIDATE” attribute.

Page 4 Release T24R05

Temenos T24 Media TSDK & Web Services.doc

Figure 5 - Architecture for Web Server APIs

The web server API must be written in java and must implement the Validator interface.
Refer to the javadoc for full details. Below is an example code fragment that validates a
currency:

Figure 6 - Example code fragment for web server API

The response that is sent to the client browser is governed by the ValidationResponse
class. Again, refer to the javadoc for details.

Page 5 Release T24R05

Temenos T24 Media TSDK & Web Services.doc
T24 Web Services

TWS Foundation
T24 WS Foundation is produced by TEMENOS and provides the building blocks for the
creation of web services from T24. It is heavily reliant on the underlying TSDK foundation
classes.

The security context service currently allows the simple method of providing a user name
and password as the security context. In future releases, a token may be passed that has
previously been generated from the security context service. In the same way as the
Browser, the concept here is that there is a “sign on” to the security context service.

Added to this are services that deal with the construction of the OFS or OFSML messages
from the contract or enquiry class.

WS Foundation is available in java providing support for the created web services on the
J2EE platform.

WS Created Classes
The TWS offering creates web services components from the business object definitions in
T24 using the VERSION and ENQUIRY applications.

Simply, the application WS.CREATE specifies the necessary information to create the web
service, and then T24 runs through the creation process to create classes that represent
the “code behind” package for the web service. In T24 r5, the concept of the “code behind”
package is to use a third party tool to create the web service itself (WSDL, SOAP listener,
etc.) from the generated classes.

The Base class inherits from either the Contract or Enquiry super class, and provides the
basis for the implementation of the web service class. The web service class inherits from
the base class, and exposes the method to be exposed as the web service. The WS class
is the suggested point for customisation.

Standard query features of T24 enable all of the generated files to be viewed.

Architecture
The calling application uses the produced WS client, via a java call. This allows means
that there is no need to produce the underlying SOAP documents. The WS client produces
the WS request and sends the request to the WS class (usually over http).

The web service request is passed into the underlying WS classes and any customisation
invoked, and then is passed onto the WS foundation layer as a java call. At this point the
WS foundation layer generates the OFSML message and hands the message to the
connector, which in turn hands the message into T24 where the message is processed.

The OFSML response is handed back through the connector to the WS foundation layer,
where the response is transformed into the required format, and handed on the WS
classes and WS client via java calls.

Page 6 Release T24R05

Temenos T24 Media TSDK & Web Services.doc
Of course, the WS client classes are not required, and the web services can be interacted
with directly via web service request / response messages.

Customising Web Services using the TSDK

Below is a code extract from a generated web service that has been modified to include
additional validation:

Figure 7 - Example code fragment with additional validation

Page 7 Release T24R05