Environment vaariobale setting in windows

TAFJ_HOME
T24_HOME
JAVA_HOME TO BE SETUP TO THE CORRECT PATH
launch-pg.bat
launch-jboss.bat

Setup tafJ

JQL
tRUN EX

tajfj conf < tafj.properties file

Thanks for confirming you're using TAFJ on a Windows localhost. Let's now narrow down why
tRun ex is not working in your local TAFJ setup on Windows. This is a common issue and can be
fixed with a few checks.

✅ What You Need to Run tRun ex on TAFJ (Windows)

To successfully run tRun ex, your setup must have:
1. ✅ Java properly installed (Java 11 preferred)
2. ✅ TAFJ binaries set up
3. ✅ A valid TAFJ.properties file
4. ✅ Correct environment variables (JAVA_HOME, TAFJ_HOME, PATH)
5. ✅ You're executing tRun from a Temenos TAFJ shell (usually a pre-configured command
prompt)

🔍 Common Reasons Why tRun ex Fails on TAFJ (Windows)

1. ❌ tRun is not recognized
Error: 'tRun' is not recognized as an internal or external command
✔️Fix:
 Add TAFJ bin to your PATH:
 set TAFJ_HOME=C:\Temenos\TAFJ
 set PATH=%TAFJ_HOME%\bin;%PATH%
 Or run from the proper TAFJ command shell provided by Temenos (if available).

2. ❌ tRun runs but fails silently or gives Java/classpath errors

Possible Cause: Misconfigured TAFJ.properties or missing dependencies.
✔️Fix:
Ensure TAFJ.properties is correctly configured:
db.url=jdbc:oracle:thin:@localhost:1521:xe
db.username=T24
db.password=yourpass
phantom.path=C:/Temenos/TAFJ/phantom
compile.path=C:/Temenos/TAFJ/compile
Then, explicitly tell tRun to use the properties:
tRun -Dconfig.file=C:\Temenos\TAFJ\TAFJ.properties ex
Or set an environment variable:
set CONFIG_FILE=C:\Temenos\TAFJ\TAFJ.properties

3. ❌ Java class not found or module not compiled

Error: ClassNotFoundException or ex not found
✔️Fix:
Make sure the routine exists:
dir /b C:\Temenos\TAFJ\source\BP\ex.java
If not compiled:
tCompile ex
Then run:
tRun ex

4. ❌ Database/connection issues
Error: Unable to connect to DB or load configuration
✔️Fix:
Check that:
 Oracle is running
 TAFJ properties use correct DB credentials
 JDBC driver is in classpath (like ojdbc8.jar)

✅ Quick Checklist for Windows (TAFJ)

What to Check How to Fix
Java is installed java -version
Environment variables Set JAVA_HOME, TAFJ_HOME, PATH
tRun in path Run where tRun
Properties file Use -Dconfig.file=... or set CONFIG_FILE
DB is reachable Use correct URL in TAFJ.properties
Routine compiled Use tCompile ex before tRun ex

Would you like to share:

 The exact error message you get from tRun ex, or
 A sample of your TAFJ.properties file (excluding sensitive info)?
That would help pinpoint the problem faster.
Naitenace date in SPF

MAAINTENANCE CODE = 179198178M

In TAFJ, you cannot write traditional T24 "BASIC" programs like you do in TAFC/jBASE (with ED,
JED, TEDIT, etc.) because TAFJ does not use jBASE. Instead, TAFJ replaces BASIC with Java, so
any routine (like EX, ENQUIRY.ROUTINE, etc.) is written in Java, compiled with tCompile, and
executed within the Java runtime.

🟨 So, in short:
✅ TAFC (jBASE-based) → uses BASIC
✅ TAFJ (Java-based) → uses Java classes instead

🟢 But you can write a "BASIC-like" routine using Java in TAFJ

Let’s simulate a BASIC-style T24 routine in TAFJ using Java by following this process:

✅ 1. Simulated BASIC Logic in Java (MYPROGRAM.java)

Suppose this is a BASIC program in TAFC:
SUBROUTINE MYPROGRAM(INPUT1, OUTPUT1)
OUTPUT1 = "HELLO " : INPUT1
RETURN
END
🔁 Java version in TAFJ:
import com.temenos.t24.api.routines.T24Routine;

public class MYPROGRAM extends T24Routine {

@Override
public void routine() {
// Simulating input from a T24 field
String input = this.getInput("INPUT1");

// Simulating output back to the application

String output = "HELLO " + input;
this.setOutput("OUTPUT1", output);

this.debug("MYPROGRAM ran with input: " + input + ", output: " + output);
}
}

✅ 2. Save and Compile

Save as:
C:\Temenos\TAFJ\source\BP\MYPROGRAM.java
Then run:
tCompile MYPROGRAM

✅ 3. Use in T24
This routine can now be linked to:
 A VERSION field routine
 A T24 Button
 A Service or ENQUIRY.ROUTINE
 Or triggered via tRun MYPROGRAM for testing

🧠 Optional: Use setReturn() instead of setOutput()

If you're just returning one value:
this.setReturn("HELLO " + input);

❗ Summary
Feature TAFC TAFJ
Language BASIC Java
Editor JED, ED, TEDIT Any text editor / Eclipse
Compiler BASIC, COMPILE tCompile
Run T.RUN, T.INSERT tRun, Workbench

Would you like a full Java version of a real BASIC program you're trying to convert to TAFJ? Just
share the original code.

Thanks — since you're setting up Temenos Design Studio for TAFJ development on a Windows
local host, here's a detailed, simplified guide tailored to that environment.

✅ Objective:
Set up a working TAFJ + Design Studio (Eclipse) development environment on Windows, so you
can create, compile, and run routines for Temenos Transact (T24) locally.

🔧 What You Need:

Component Description
Java JDK Install JDK 8 or 11 (TAFJ requires it)
Eclipse IDE (Design Studio) Temenos’ Eclipse with plugins or stock Eclipse
TAFJ Engine The backend engine to compile/run Java routines
T24 Environment (Local) Usually a mock or dev instance if real T24 is not available
OFS or DB access Optional for integration (often simulated locally)
Temenos JARs e.g., t24-api.jar, tafj-utils.jar (from Temenos)

🧰 Step-by-Step Setup on Windows

1️⃣ Install Java JDK
 Download from Oracle
 Set environment variables:
set JAVA_HOME=C:\Program Files\Java\jdk1.8.0_xx
set PATH=%JAVA_HOME%\bin;%PATH%
2️⃣ Install Eclipse IDE (Temenos Design Studio)
 Use the Temenos-provided Design Studio if you have it.
 Or download Eclipse IDE for Java Developers.
 Unzip to C:\Temenos\Eclipse
3️⃣ Install Temenos Plugins (if needed)
 Launch Eclipse → Help > Install New Software
 Use a Temenos plugin .zip or update URL (from your bank or Temenos)
 Install:
o TAFJ Tools
o T24 Routine Wizards
o OFS/OFS Adapter (optional)
⚠️You will not be able to install these without Temenos access or SDK.

4️⃣ Set Up TAFJ Locally

Assuming you have the TAFJ package:
C:\Temenos\TAFJ\
├── source\ ← Source .java files (e.g., EX.java)
├── classes\ ← Compiled .class files
├── lib\ ← t24-api.jar, tafj-utils.jar
├── logs\
├── TAFJ.properties
Example TAFJ.properties:
source.path=C:/Temenos/TAFJ/source
compile.path=C:/Temenos/TAFJ/classes
log.path=C:/Temenos/TAFJ/logs

5️⃣ Create a New T24 Project in Eclipse

 File > New > Project > Temenos > T24 Routine Project
 Source folder: C:/Temenos/TAFJ/source
 Output folder: C:/Temenos/TAFJ/classes
Add Libraries:
 Right-click project > Properties > Java Build Path > Libraries
 Add:
o t24-api.jar
o tafj-utils.jar

6️⃣ Write and Compile a Routine

EX.java
import com.temenos.t24.api.routines.T24Routine;

public class EX extends T24Routine {

@Override
public void routine() {
this.setReturn("Routine executed successfully.");
 }
}
 Save in: C:/Temenos/TAFJ/source/BP/EX.java
 Right-click > TAFJ Tools > Compile

7️⃣ Run Locally

In a command prompt:
cd C:\Temenos\TAFJ
tRun EX
If tRun isn’t recognized, ensure:
 TAFJ/bin is in your system’s PATH
 tRun has execute permissions

🛠 Optional: OFS Connection Setup

If you're testing OFS messages:
 Use OFS Adapter (or mock)
 Configure:
ofs.source=INPUTTOSERVER, EQ TELLER,USER,INPUTTOSERVER,OFS.USER,/HOST/PORT

🧪 Testing Your Setup

To confirm it's working:
 tRun EX should show:
 Routine executed successfully.

❗ Troubleshooting
Issue Fix
tRun not found Add TAFJ/bin to system PATH
Compile errors Check t24-api.jar is in classpath
OFS errors Verify host/port and user configuration
Java version Use JDK 8 or 11 only

Would you like a sample ready-made folder structure with EX.java and TAFJ.properties you can
run directly?
It looks like you're referring to DSF-SWERVER — but that term seems misspelled or unclear.
Based on your context (working with T24/TAFJ on a Windows local host), I’ll suggest the most
likely possibilities:

🔍 Possibilities for "DSF-SWERVER"

You Might
Explanation
Mean
Temenos Deployment Service Framework (DSF) — part of Temenos
DSF Server
architecture used to deploy services in TAFJ environments.
Design Studio The backend integration for Design Studio (Eclipse), which connects to T24 or
You Might
Explanation
Mean
Server OFS adapters.
Sometimes referred to as an OFS “server” or listener that allows you to send
OFS Server
OFS messages from external apps or Design Studio.
The Java application server running TAFJ, where routines are deployed and
TAFJ Server
tested.
Typo for TAFJ If "DSF-SWERVER" is a typo, you may be asking how to start or configure the
Server TAFJ runtime.

🧰 If You’re Referring to TAFJ/DSF Server

Here's how to run and configure the TAFJ Server on Windows:
✅ Start the TAFJ Runtime (Java server)
1. Open a terminal (Command Prompt or PowerShell).
2. Navigate to your TAFJ directory:
3. cd C:\Temenos\TAFJ\bin
4. Start the server:
5. start.bat
This will start the TAFJ runtime (e.g., equivalent to a Java web service container).

⚙️Configure DSF/TAFJ Properties

In your TAFJ.properties or environment.properties, ensure paths and ports are configured:
source.path=C:/Temenos/TAFJ/source
compile.path=C:/Temenos/TAFJ/classes
log.path=C:/Temenos/TAFJ/logs
server.port=8181

🧪 Test: Connect from Design Studio

Once the server is running:
 In Eclipse: Window > Preferences > Temenos > T24 Connection
 Add or edit a connection:
o Host: localhost
o Port: 8181 (or your configured TAFJ port)
o User/OFS Source: as configured in OFS message setup
 Click Test Connection

🧩 Need Clarification?
If you meant something specific like:
 DSF server setup
 Design Studio backend connection
 Web server for OFS routing
 Or something else entirely...
Please clarify or correct the term "DSF-SWERVER" so I can guide you more accurately.
Would you like help setting up an OFS listener or a full TAFJ local runtime example?
If you're seeing the "no repository found" message in the Design Studio T24 log file, it usually
means that the Design Studio is unable to locate or connect to the T24/TAFJ repository. The
repository is essential for accessing metadata like versions, enquiries, routines, etc.

🔍 Possible Causes & Fixes

1. ❌ No Repository Configured
Cause: You haven’t configured the T24 repository in Design Studio.
Fix:
 Go to Window > Preferences > Temenos > T24 Repository
 Click Add Repository
 Enter:
o Name: e.g., LocalT24
o Host: localhost or your T24 server IP
o Port: Port number TAFJ/OFS is listening on (e.g., 8181, 8080, or 4100)
o User ID and Password: Your T24 credentials
o OFS Source: e.g., DESIGNSTUDIO
 Click Test Connection
 Save it once successful

2. ⚙️OFS Adapter or Middleware Not Running

Cause: The OFS adapter or OFS listener service isn’t running on your T24 environment.
Fix:
 Check if OFS is configured and running on the server (often through a script or web
service).
 Restart the OFS listener service, if applicable.

3. 🔒 Firewall or Network Issues

Cause: Design Studio can't reach the T24 backend due to a firewall or incorrect network path.
Fix:
 Try pinging the host and port from your machine:
 telnet localhost 8181
If it fails, the port is either closed or the service isn’t running.

4. 📁 Corrupt or Incomplete Workspace

Cause: The Design Studio workspace is broken or missing metadata.
Fix:
 Try creating a new workspace:
o File > Switch Workspace > Other
o Create a fresh one, e.g., C:\Temenos\workspace2
o Recreate the repository config.

5. 🔧 Design Studio Not Pointing to Correct JARs or Engine

Cause: Your TAFJ engine or T24 plugins are misconfigured.
Fix:
 Check:
o TAFJ libraries (e.g., t24-api.jar) are added to your Eclipse project
o TAFJ.properties has correct paths
 Recompile and reload the project

✅ Checklist to Resolve “No Repository Found”

Check Status
Add repository under Window > Preferences > Temenos > T24 Repository ✅
Test connection (host, port, user, OFS) ✅
Ensure TAFJ server or OFS Adapter is running ✅
Verify network connectivity to T24 backend ✅
Restart Design Studio / Use fresh workspace ✅

Would you like help walking through the repository setup screen in Design Studio with example
values?

-====
In Temenos T24, especially on TAFJ (Java-based) platforms, JED is not supported directly in the
way it is on jBASE systems. However, if you're using JQL (jBASE Query Language) and want to
view or edit program files (like routines or records), here’s what you need to know:

🚫 JED Is Not Supported on TAFJ

 JED is a jBASE editor used on TAFC (C-based T24 environments) or jBASE-based systems.
 On TAFJ (Java) platforms, routines and programs are typically written in Java, not in
jBASE BASIC, and source files are handled using Eclipse (Design Studio), not via terminal
editors.

✅ TAFJ Alternatives to JED

Task Use This Instead
View/edit routines Use Design Studio (Eclipse) to edit .java files in BP/ folder
View records Use JQL SELECT and LIST commands
Compile Use TAFJ Tools > Compile in Eclipse or tCompile from terminal
Execute routine Use tRun <RoutineName>

🔎 Example JQL Usage on TAFJ

To view or select records, you can use:
SELECT F.T24.VERSION WITH @ID LIKE 'CUSTOM%'
Then list them:
LIST F.T24.VERSION
You can also use:
LIST F.BP EX
🔸 This lists the EX routine source if it exists in the BP folder (though editing is done in Eclipse).

📝 If You Still Want to Edit Files via Terminal

If you're using jBASE (on TAFC), then JED works like this:
JED BP EX
But for TAFJ, this won’t work because:
 There's no jBASE BASIC editor available
 The source is Java, and stored as .java files in folders like source/BP/EX.java

✅ Recommended Way to Edit in TAFJ

Use Design Studio or any Java IDE:
1. Open EX.java in Eclipse
2. Write your logic using T24Routine class
3. Right-click > TAFJ Tools > Compile
4. Run with:
5. tRun EX

Let me know if you want a template for EX.java or need help running a tRun routine from your
terminal.
TAFJ (Temenos Application Framework for Java) is the framework used for building and
customizing Temenos applications, primarily within T24 Transact. If you are looking to write
basic code in TAFJ, you'll typically be working with Java code that interacts with T24, extending
its functionality, implementing custom business logic, or creating new features for the
application.
Steps to Write Basic Code in TAFJ (Temenos Application Framework for Java):

1. Set Up Development Environment

Before you start writing code in TAFJ, you need to set up your development environment:
 Install Java Development Kit (JDK): Ensure that you have a compatible version of JDK
(Java Development Kit) installed. TAFJ typically supports JDK versions 8 and higher.
 TAFJ SDK (Software Development Kit): Ensure you have access to the TAFJ SDK. This SDK
contains the necessary libraries and tools to develop applications in TAFJ.
 T24 Development Environment: Set up a development instance of T24, as you'll need to
deploy and test your code within the T24 environment.
 Integrated Development Environment (IDE): Use an IDE such as Eclipse or IntelliJ IDEA
for writing Java code. Ensure you have configured your IDE with the TAFJ SDK libraries.

2. Understand the TAFJ Structure

TAFJ code generally follows a service-oriented architecture and operates around the concept of:
 Services: Java classes that implement business logic and interact with T24.
 Requests and Responses: TAFJ uses a request-response model for interactions with the
T24 system, typically in the form of messages or data objects.
 Temenos API: TAFJ exposes APIs that allow you to interact with the T24 core system,
databases, and other business functions.
3. Create a New Java Class for Your Service
To create a simple TAFJ service, you will need to write a Java class that will contain the business
logic you want to implement. Here’s an example of creating a simple service.
1. Create a new class (e.g., LoanService.java) that will contain your service logic.
2. Define the method(s) that will execute specific business rules or operations within T24.
Here’s a basic template for a TAFJ service:
import com.temenos.tafj.core.logging.Logger;
import com.temenos.tafj.core.message.RequestMessage;
import com.temenos.tafj.core.message.ResponseMessage;
import com.temenos.tafj.core.service.Service;
import com.temenos.tafj.core.service.ServiceException;

public class LoanService implements Service {

private static final Logger logger = Logger.getLogger(LoanService.class);

@Override
public ResponseMessage execute(RequestMessage request) throws ServiceException {
// Extract parameters from the request
String loanType = request.getParameter("loanType");
double loanAmount = Double.parseDouble(request.getParameter("loanAmount"));
// Business logic for processing the loan (e.g., checking loan type and calculating interest)
double interest = calculateLoanInterest(loanAmount, loanType);
// Prepare the response
ResponseMessage response = new ResponseMessage();
response.addParameter("loanInterest", interest);
// Log the process
logger.info("Processed loan with type: " + loanType + " and amount: " + loanAmount);
return response;
}

private double calculateLoanInterest(double amount, String type) {

// Example of simple interest calculation based on loan type
double interestRate = (type.equals("home")) ? 0.05 : 0.07;
return amount * interestRate;
}
}
4. Explanation of Code Structure
 Imports: You need to import the relevant TAFJ classes. For example, RequestMessage,
ResponseMessage, and Service are used to manage requests and responses.
 Service Interface: Your class implements the Service interface. The execute method is
required, and it contains the logic for processing a request.
  RequestMessage: This class is used to receive input parameters, such as loanType and
loanAmount.
 ResponseMessage: This is used to send the results back, for example, the calculated
interest rate.
 Logging: Logger is used to log the service execution and data for debugging and
monitoring.

5. Compile and Package the Code

Once you’ve written your Java service, you need to compile it and package it into a JAR file. Here
are the steps:
1. Compile the Code: If you’re using an IDE like Eclipse or IntelliJ, simply click on "Build" to
compile the code.
2. Package into JAR: Create a JAR (Java Archive) file containing your compiled classes and
dependencies.
o In Eclipse, right-click on the project, select Export → JAR file.
o In IntelliJ, use Build → Build Artifacts.

6. Deploy the Service to T24

After packaging your service as a JAR file, the next step is to deploy it to the T24 server:
1. Copy the JAR File: Place the JAR file into the appropriate directory on the T24
application server. The directory will typically be configured to recognize custom
services.
2. Update T24 Configuration:
o In T24, you will need to create an entry in the Service Registry to register your
newly created service. This allows T24 to recognize the service and make it
callable from within the system.
o You may need to update the Service Configuration or create an entry in the T24
Application Profile to link the service with relevant modules or transactions.

7. Testing the Service

Once the service is deployed, you can test it within the T24 system using various testing tools,
or by integrating it with other T24 modules that invoke the service.
 Using T24 Directly: You can create a test transaction or batch job that calls your new
service and provides input parameters to test the service.
 Integration Testing: You can also call your service from another application or via T24’s
RESTful or SOAP-based web services to check how it behaves in a real scenario.

8. Monitor and Debug

While developing and testing your service, it's important to monitor logs and debug any issues:
 Logging: Use the Logger class to add logging statements at various points in your code to
track inputs, outputs, and business logic execution.
 T24 Logs: Ensure that you check T24 logs for any issues related to the deployment and
execution of your service.
  Debugging: Use breakpoints and debugging tools available in your IDE to step through
the service execution.

9. Handle Errors and Exceptions

In TAFJ, you will need to handle exceptions to ensure that the system behaves as expected
under error conditions. For example, you might encounter invalid input parameters or system
failures during execution. Here’s an example of how to handle exceptions:
@Override
public ResponseMessage execute(RequestMessage request) throws ServiceException {
try {
// Your business logic
String loanType = request.getParameter("loanType");
if (loanType == null) {
throw new ServiceException("Loan type is missing");
}
double loanAmount = Double.parseDouble(request.getParameter("loanAmount"));

// Your calculation logic

double interest = calculateLoanInterest(loanAmount, loanType);

// Prepare and return the response

ResponseMessage response = new ResponseMessage();
response.addParameter("loanInterest", interest);
return response;
} catch (Exception e) {
logger.error("Error processing loan request", e);
throw new ServiceException("Error processing loan request: " + e.getMessage());
}
}

10. Deploy Updates to T24

Once you've made your changes, you will need to redeploy the updated JAR file and restart
relevant services on the T24 application server for the changes to take effect.

Conclusion
In summary, writing basic code in TAFJ involves creating Java classes to implement business
logic, packaging those classes into JAR files, and deploying them within the T24 system. By
following these steps—setting up the environment, creating Java classes for services, compiling
the code, deploying, testing, and debugging—you can successfully extend the functionality of
T24 using TAFJ.