CICS Programming Models

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
CUSTINQ: PROCEDURE OPTIONS(MAIN);
    DECLARE CUSTOMER_ID CHAR(10);
    DECLARE CUSTOMER_NAME CHAR(30);
    
    /* Receive customer data from terminal */
    EXEC CICS RECEIVE MAP('CUSTMAP')
                     MAPSET('CUSTSET')
                     INTO(CUSTOMER_ID);
    
    /* Process customer inquiry */
    /* ... business logic here ... */
    
    /* Send response to terminal */
    EXEC CICS SEND MAP('CUSTMAP')
                 MAPSET('CUSTSET')
                 FROM(CUSTOMER_NAME);
    
    EXEC CICS RETURN;
END CUSTINQ;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import com.ibm.cics.server.*;
import java.io.*;
 
public class CustomerInquiry {
    public static void main(CommAreaHolder cah) {
        try {
            // Get terminal input
            Terminal terminal = new Terminal();
            String customerId = terminal.receive();
            
            // Process customer inquiry
            String customerName = processCustomer(customerId);
            
            // Send response to terminal
            terminal.send(customerName);
            
        } catch (CicsException e) {
            // Handle CICS errors
            System.err.println("CICS Error: " + e.getMessage());
        }
    }
    
    private static String processCustomer(String id) {
        // Business logic implementation
        return "Customer: " + id;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
const express = require('express');
const { CicsConnection } = require('@ibm/cics-node');
 
const app = express();
const port = 3000;
 
// CICS connection
const cics = new CicsConnection({
  region: 'CICSREG',
  connection: 'DFHCNCT'
});
 
app.get('/customer/:id', async (req, res) => {
  try {
    const customerId = req.params.id;
    
    // Call CICS program
    const result = await cics.link({
      program: 'CUSTINQ',
      commarea: customerId
    });
    
    res.json({ customer: result });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});
 
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// GET /api/customers/12345
{
  "customerId": "12345",
  "customerName": "John Doe",
  "email": "john.doe@example.com",
  "status": "active"
}
 
// POST /api/customers
{
  "customerName": "Jane Smith",
  "email": "jane.smith@example.com"
}
 
// HTTP Status Codes
200 OK - Success
201 Created - Resource created
400 Bad Request - Invalid input
404 Not Found - Resource not found
500 Internal Server Error - Server error

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import com.ibm.mq.jms.MQQueueConnectionFactory;
import javax.jms.*;
 
public class CustomerMessageConsumer {
    public void startListening() {
        try {
            // Create connection factory
            MQQueueConnectionFactory factory = new MQQueueConnectionFactory();
            factory.setHostName("localhost");
            factory.setPort(1414);
            factory.setQueueManager("QMGR");
            
            // Create connection and session
            Connection connection = factory.createConnection();
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            
            // Create queue and consumer
            Queue queue = session.createQueue("CUSTOMER.UPDATES");
            MessageConsumer consumer = session.createMessageListener(new MessageListener() {
                public void onMessage(Message message) {
                    try {
                        if (message instanceof TextMessage) {
                            String text = ((TextMessage) message).getText();
                            String customerId = message.getStringProperty("CustomerID");
                            processCustomerUpdate(customerId, text);
                        }
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            });
            
            connection.start();
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
    
    private void processCustomerUpdate(String customerId, String update) {
        // Process customer update
        System.out.println("Processing update for customer: " + customerId);
    }
}