Extensibility in Quantum Fabric

This section details the various features and scenarios to use extensibility in Quantum Fabric. A developer can add, delete, or modify multiple services associated with the base Temenos Digital application using extensibility. Adding the extensions to the Temenos Digital application enables the developer to customize the application per the business requirement.

The following topics are available on this page.

• Architecture of Fabric Apps
• Locking
• Extension in Services
• Extension Scenarios

Architecture Of Fabric Apps

2021.04 Release and Prior

The Quantum Fabric apps for Temenos Digital application 2021.04 and prior uses a single Fabric app: DbpLocalServices with one large object service, RBObjects. This object service contains multiple objects with verbs for each integration service. The integration services used can be broadly classified as:

• Microservices Integration
• Transact Integration
• Native Platform Functionality

2021.07 Release and Later

Temenos Digital application for Mobile and Online Banking has made a major change in the Quantum Fabric app post the release 2021.04. The Quantum Fabric apps for Temenos Digital application 2021.07 and later still uses the single Fabric app: DbpLocalServices. However, every functional module now maps to a different object service and not was mapped to one large object service.

The number of object verbs and integration services in this architecture is the same as in the previous architecture.

Locking

The Locking feature of the Quantum Fabric helps the Temenos Digital application developers define the application's base functionality. The Quantum Fabric app delivered along with the Temenos Digital app is always in a locked state. A customer can add the extensions to the base app to make the customizations without modifying the app functionality. If a new version of this base app is released, the customer can update the app to get the latest features with no changes to the Extensions.

For more information on Locking and adding extensions, refer to the Quantum Fabric User Guide.

Extension in Services

Temenos Digital application supports various extensions in the services. This section details the possible extensions for each type of service.

• Object Services
• Integration Services

Object Services

Object Service is a model-driven application design that follows a microservices architecture to create a reusable component. A developer can then link the reusable component to fit the requirement. Using extensibility in Object services, a developer can add the following features.

• Add new custom pre/ post-processors.
• Disable existing pre/ post-processors.
• Re-order the execution sequence of the pre/ post-processors.
• Add another mapper to a verb.

Integration Services

An Integration Service is the service that helps the application interact with an external system or data source. The Integration service can have different configurations such as service type, Endpoint URLs, service ID, HTTP/ HTTPS, request parameters, response parameters, pre/ post processors, and authentication credentials. Temenos Digital application helps the user to

A developer can use extensions to customize the following in the Integration services that use Java Services.

• Add new custom pre/ post-processors.
• Disable existing pre/ post-processors.
• Re-order the execution sequence of the pre/ post-processors.
• Add new Request and Response fields.

A developer can use extensions to customize the following in the Integration services that use JSON Services.

• Set or modify the following values.
  • Enable Custom Front End URL
  • Resource Method
  • Web Service Authentication
  • Identity Service for Back-end Token
  • URL Provider Class
  • Path Expression
  • Target HTTP Method
  • Operation Security Level
  • Enable pass-through
• Add new custom pre/ post-processors.
• Disable existing pre/ post-processors.
• Add new Request and Response fields.
• Modify Target URL

A developer can use extensions to customize the following in the Integration services that use RDMS Services.

• Add new Request and Response fields.
• Add new custom pre/ post-processors.
• Disable existing pre/ post-processors.
• Change security filters of RDBMS service GET operation.
• Connection Parameters
• Add a new Table.
• Add an operation for the existing RDBMS service.
• Add a new column to an existing table.

Extension Scenarios

An extension is a very useful and powerful tool for a developer to customize the app to suit a customer's requirements. This section discusses some common scenarios for using extensibility in the app and the guidelines a developer must follow.

• Point to a New Integration Service with Four-Layer Architecture
• Point to an Existing Integration Service with Four-Layer Architecture
• Extend From a Non-Product Service
• Enhancements to JAVA Service

Point to a New Integration Service with Four-Layer Architecture

One of the common scenarios that a developer will encounter is to point to a new Integration service with a Four-layered architecture. For example, to integrate a new Payments vendor service for making transfers between banks. For more information about the Four-layered architecture, refer to the Experience APIs with Four-Layered Architecture section.

Here are the different cases that a developer might encounter while pointing to a new integration service.

• Back-end Delegate Exists: To use an existing back-end delegate, follow these steps.
  1. Create a new JAVA project in a tool such as an eclipse.
  2. Implement the back-end delegate interface for a class inside the JAVA project.
  3. Register the implemented class as an extension in the servlet class.
     During run-time, the framework JAR prioritizes the extension and loads this class to call any methods defined inside the interface.
• Back-end Delegate Does Not Exist:

Point to an Existing Integration Service with Four-layer Architecture

When the developer must extend the existing functionality of an integration service in the four-layered architecture, the developer should extend different layers, such as the JAVA service and Business Delegate. For example, adding new input parameters and output responses per the customer/ vendor endpoint.

Here are some classes a developer may need to extend per the requirement.

• Extend an existing Data Transfer Object (DTO) to add new request parameters.
• Extend an existing Resource delegate class that uses the newly extended DTO. The developer must register this resource class as an extension in the servlet class.
• Extend an existing Business delegate class that uses the newly extended DTO. The developer must register this business class as an extension in the servlet class.
• Extend an existing Back-end delegate class that uses the newly extended DTO. The developer must register this back-end delegate class as an extension in the servlet class.

Extend From a Non-Product Service

If the service does not follow a four-layer architecture, the developer can follow any of these steps to extend the functionality.

• Using a JAVA service: To use this method, the developer must first create a new JAVA service and map the new service to an existing JAVA integration service operation. Temenos Digital application does not consider this type of customization during the upgrade process. The developer must re-map the service after every upgrade.
• Using Pre-processor: This is a standard and recommended extensibility option supported by Quantum. To use this method, the developer must create a new pre-processor that returns after executing the service call.

If the non-product service follows a four-layer architecture, follow the steps given in the Point to an Existing Integration Service with Four-layered Architecture section.

Enhancements to JAVA Service

Another business use case that requires extensibility is when a developer has to make enhancements to a JAVA service in DBPLocalServices that invokes the Admin Console Object verbs. A good example is when the developer has to add a new Account number while creating a Secure message.

Here are the steps the developer must follow to add enhancements to a JAVA service.

1. Extend the integration and object service in Spotlight to accept new request parameters. To extend a JAVA service, follow the steps in Extend From a Non-Product Service section.
2. Extend the JSON service. To extend a JSON service that calls a JAVA service, follow the steps given in Extend From a Non-Product Service section.
3. Extend the Object service in DBPLocalServices for the new request parameter.

The JAVA service can also fetch/ update data from a Database. To perform this action, follow these steps.

1. Create a Flyway script to extend a table.
2. Extend the existing CRUD database operations.
3. Extend the JAVA integration service by following the Extend From a Non-Product Service section.

If the pre/post-processor calls the Database service inside it, follow these steps.

1. Create a new pre/ post-processor.
2. Attach the new pre/ post-processor to the required DB service operation.
3. Disable the existing pre/ post-processor.