Instructions d’intégration

{
  "action": "authenticate",
  "apiToken": "P14i5WS4P0uhgbrnN7BZ",
  "cloudApiVersion": "1.0",
  "merchantId": "1234567890",
  "requestId": "I9000001-20250707-001",
  "requestTimestamp": "2025-07-07 10:00:00"
}

{
  "status": "200",
  "statusDesc": "OK"
}

{
  "action": "echo",
  "apiToken": "P14i5WS4P0uhgbrnN7BZ",
  "cloudApiVersion": "1.0",
  "merchantId": "1234567890",
  "requestId": "I9000001-20250707-002",
  "requestTimestamp": "2025-07-07 10:00:30"
}

{
  "terminalId": "I9000001",
  "merchantId": "1234567890",
  "apiVersion": "1.0",
  "requestId": "I9000001-20250707-003",
  "requestTimestamp": "2025-07-07 10:01:00",
  "action": "getTables",
  "data": {
    "server": {
      "serverId": "1234"
    }
  }
}

{
  "status": "200",
  "data": {
    "tables": [
      {
        "tableId": "T123",
        "tableName": "Patio-4",
        "tableTotalAmount": 6400,
        "tableRemainingAmount": 6400
      },
      {
        "tableId": "T124",
        "tableName": "Main Hall-7",
        "tableTotalAmount": 8200,
        "tableRemainingAmount": 3200
      }
    ]
  }
}

{
  "terminalId": "I9000001",
  "merchantId": "1234567890",
  "apiVersion": "1.0",
  "requestId": "I9000001-20250707-004",
  "requestTimestamp": "2025-07-07 10:01:10",
  "action": "getTable",
  "data": {
    "server": {
      "serverId": "1234"
    },
    "tableId": "T123"
  }
}

{
  "status": "200",
  "data": {
    "table": {
      "tableName": "Patio-4",
      "tableTotalAmount": 6400,
      "splitMethod": 1,
      "masterCheck": {
        "checkId": "1",
        "checkName": "Full Table",
        "totalAmount": 6400,
        "remainingAmount": 6400
      }
    }
  }
}

{
  "terminalId": "I9000001",
  "merchantId": "1234567890",
  "apiVersion": "1.0",
  "requestId": "I9000001-20250707-004",
  "requestTimestamp": "2025-07-07 10:01:10",
  "action": "getTable",
  "data": {
    "server": {
      "serverId": "1234"
    },
    "tableId": "T123"
  }
}

{
  "terminalId": "I4123456",
  "merchantId": "00312312312312",
  "configCode": "C12345678SI",
  "requestId": "I4123456-2025-08-18-002",
  "responseTimestamp": "2025-08-18 10:01:00",
  "status": "200",
  "statusDesc": "OK",
  "data": {
    "table": {
      "tableId": "01",
      "tableName": "Table 1",
      "tableTotalAmount": 4200,
      "tableRemainingAmount": 4200,
      "splitMethod": 3,
      "masterCheck": {
        "checkId": "1",
        "checkName": "Full Table",
        "totalAmount": 4200,
        "preTaxAmount": 0,
        "remainingAmount": 4200,
        "receipt": {
          "taxes": [],
          "discounts": [],
          "lineItems": []
        }
      },
      "checks": [
        {
          "checkId": "1",
          "checkName": "Check 1",
          "totalAmount": 2000,
          "preTaxAmount": 0,
          "gratuity": 0,
          "remainingAmount": 2000,
          "receipt": {
            "taxes": [],
            "discounts": [],
            "lineItems": []
          }
        },
        {
          "checkId": "2",
          "checkName": "Check 2",
          "totalAmount": 2200,
          "preTaxAmount": 0,
          "remainingAmount": 2200,
          "receipt": {
            "taxes": [],
            "discounts": [],
            "lineItems": []
          }
        }
      ]
    }
  }
}

{
  "terminalId": "I9000001",
  "merchantId": "1234567890",
  "apiVersion": "1.0",
  "requestId": "I9000001-20250707-005",
  "idempotencyKey": "74ae1696-b1e3-4328-af6d-f1e04d947a13",
  "requestTimestamp": "2025-07-07 10:02:00",
  "action": "applyPayment",
  "data": {
    "server": {
      "serverId": "1234"
    },
    "check": {
      "tableId": "T123",
      "checkId": "1"
    },
    "payment": {
      "tenderType": "CARD",
      "card": {
        "cardType": "VISA",
        "authNumber": "183235",
        "referenceNumber": "1020293",
        "lastDigits": "1234"
      },
      "paidAmount": 5400,
      "tipAmount": 1000
    }
  }
}

{
  "status": "200",
  "data": {
    "table": {
      "tableId": "T123",
      "tableRemainingAmount": 0
    },
    "check": {
      "checkId": "1",
      "remainingAmount": 0
    }
  }
}

import tls from 'tls';

let displayecho = true;

let intervalConnect = null;
let cloud_sock = null;
const ActionType = {
    echo: 'echo',
    authenticate: 'authenticate',
    getTables: 'getTables',
    getTable: 'getTable',
    applyPayment: 'applyPayment',
};

const errCodesMsgsMap = {
    '218': 'Unsupported action\tAction not supported.',
    '600': 'Internal Error',         // 600
    '601': 'Incorrect Msg Length',   // 601
    '602': 'JSON Parse Error',       // 602
    '603': 'Missing Server ID',      // 603
    '604': 'Invalid Server ID',      // 604
    '605': 'Invalid Server Tracks',  // 605
    '606': 'Missing Table ID',       // 606
    '607': 'Invalid Table ID',       // 607
    '608': 'Missing Check ID',       // 608
    '609': 'Invalid Check ID',       // 609
    '610': 'Missing Payment Obj',    // 610
    '611': 'Invalid Payment Obj',    // 611
    '612': 'Missing IdempotencyKey', // 612
    '613': 'Invalid split method',   // 613
    '614': 'Server Not Found',       // 614
    '615': 'No Table Found',         // 615
    '616': 'No Check Found'          // 616
};
const options = {
    autoconnect: true,
    reconnection: true,
    reconnectionDelay: 1000,
    reconnectionDelayMax: 2000,
    reconnectionAttempts: Infinity
};
const cloudSever = {
    host: 'patposct.moneris.com',
    port: 443
}


const getMID = function () {
    return '0030128923365';  // votre MID (identifiant marchand)
};

const getCfgCode = function () {
    return "C000497ECP";
};

const getApiToken = function () {
    return 'C7jZF1ad7IIGCoEIMGoD';
}
let getRequestId = function () {
    let now = new Date();
    return getMID() + '-' + now.toISOString();
};
let getDateTime = function () {
    const now = new Date();
    return now.toISOString().replace('T', '-').substring(0, 19);
};
// gérer "echo" (écho) toutes les 30 secondes
function startEchoInterval(cloud_sock) {
   
    // S'assurer de ne pas démarrer plusieurs intervalles
    if (cloud_sock.echoInterval) {
        clearInterval(cloud_sock.echoInterval);
    }

    cloud_sock.echoInterval = setInterval(() => {
        if (cloud_sock.gotEchoNoResponse === 0) {
            if (!cloud_sock.echoTimeout) {
                // définir 10 s comme délai d’attente pour recevoir la réponse echo (réponse d’écho)
                cloud_sock.echoTimeout = setTimeout(() => {
                    console.info('Timeout, closing connection....');
                    clearInterval(cloud_sock.echoInterval);
                    clearTimeout(cloud_sock.echoTimeout);
                    cloud_sock.echoTimeout = null;
                    cloud_sock.end();
                }, 10000);  
            }
            return;
        }

        // Construire la requête echo (écho)
        let echoRequest = {
            action: 'echo',
            apiToken: getApiToken(),
            cloudApiVersion: '1.0',
            merchantId: getMID(),
            requestId: getRequestId(),
            requestTimestamp: getDateTime()
        };

        console.info(
            '\x1b[32m',
            'Sending Echo Request: ' + new Date().toString() +
            '\n' + JSON.stringify(echoRequest, null, 2)
        );

        cloud_sock.gotEchoNoResponse = 0;
        let sendbuf = twoBytesHeaderAppender(echoRequest);
        cloud_sock.write(sendbuf);  // envoyer echo (écho)

    }, 30000); // toutes les 30 s
}

function stopEchoInterval(cloud_sock) {
    if (cloud_sock.echoInterval) {
        clearInterval(cloud_sock.echoInterval);
        cloud_sock.echoInterval = null;
    }
    if (cloud_sock.echoTimeout) {
        clearTimeout(cloud_sock.echoTimeout);
        cloud_sock.echoTimeout = null;
    }
}
// construire la réponse gettables (getTables)
function getTables(request) {

    let requestId = request.requestId;
    let session = request.session;
    let requestServerId = request.data.server.serverId; // serverId (identifiant du serveur)
    let requestTrack2;
    let tId = request.terminalId;
    let mId = request.merchantId;
    let response = {};
    response = {
        'terminalId': tId,
        'merchantId': mId,
        'configCode': getCfgCode(),
        'requestId': requestId,
        'responseTimestamp': getDateTime(),
        'session': session
    }
    if (request.data.server.serverId != undefined)
        requestServerId = request.data.server.serverId;

    if (request.data.server.trackData != undefined)
        requestTrack2 = request.data.server.trackData.track2;

    if (requestServerId === undefined && requestTrack2 === undefined) {
        response.status = "603";
        response.statusDesc = errCodesMsgsMap[response.status];
        console.info("unable to determine the serverId", request.data.server.serverId);

        return response;
    }

    // par exemple, votre serverId (identifiant du serveur) = 1234, et il y a 3 tables pour ce serverId (identifiant du serveur)
    if (requestServerId == '1234') {
        response = {
            ...response,
            'data': {
                'tables': [
                    {
                        'tableId': '00',
                        'tableName': '0020',
                        'tableTotalAmount': 15000,
                        'tableRemainingAmount': 15000
                    },
                    {
                        'tableId': '01',
                        'tableName': 'Alphabets',
                        'tableTotalAmount': 9500,
                        'tableRemainingAmount': 9500
                    },
                    {
                        'tableId': '02',
                        'tableName': 'DiningRoom7',
                        'tableTotalAmount': 24000,
                        'tableRemainingAmount': 24000
                    }
                ]
            },
            'status': '200',
            'statusDesc': 'OK'
        }
    } else {
        response.status = '614';
        response.statusDesc = errCodesMsgsMap[response.status];
    }
    return response;
}
// construire la réponse gettable (getTable)
function getTable(request) {
    let requestId = request.requestId;
    let session = request.session;
    let requestServerId = request.data.server.serverId; // serverId (identifiant du serveur)
    let tableId;
    let tId = request.terminalId;
    let mId = request.merchantId;
    let response = {};

    response = {
        'terminalId': tId,
        'merchantId': mId,
        'configCode': getCfgCode(),
        'requestId': requestId,
        'responseTimestamp': getDateTime(),
        'session': session
    }
    if (request.data.server.serverId != undefined) {
        requestServerId = request.data.server.serverId;
    } else {
        response.status = "603";
        response.statusDesc = errCodesMsgsMap[response.status];
        console.info("unable to determine the serverId", request.data.server.serverId);

        return response;
    }
    if (request.data.tableId != undefined) {
        tableId = request.data.tableId;
    } else {
        response.status = "606";
        response.statusDesc = errCodesMsgsMap[response.status];
        return response;
    }

    // par exemple, votre serverId (identifiant du serveur) = 1234, et il y a 3 tables pour ce serverId (identifiant du serveur)
    if (requestServerId == '1234') {
        // dans cet exemple de code, retourner les mêmes détails pour tableId (identifiant de table) '00' et '01' ; un code d’erreur 615 sera retourné pour tableId (identifiant de table) '03'.
        if ((tableId == '00') || (tableId == '01')) {
            response = {
                ...response,
                'data': {
                    'table': {
                        'masterCheck': {
                            'receipt': {
                                'taxes': [],
                                'discounts': [],
                                'lineItems': []
                            },
                            'checkId': '1',
                            'checkName': 'Full Table',
                            'totalAmount': 15000,
                            'preTaxAmount': 14000,
                            'remainingAmount': 15000
                        },
                        'checks': [],
                        'tableId': '00',
                        'tableName': '0020',
                        'tableTotalAmount': 15000,
                        'tableRemainingAmount': 15000,
                        'splitMethod': 1
                    }
                },
                'status': '200',
                'statusDesc': 'OK'
            }
        }
        else {
            response.status = '615';
            response.statusDesc = errCodesMsgsMap[response.status];
        }

    } else {
        response.status = '614';
        response.statusDesc = errCodesMsgsMap[response.status];
    }
    return response;
}
// traiter le paiement, mettre à jour les informations de paiement dans votre base de données
function processPayment(request) {
    let requestId = request.requestId;
    let session = request.session;
    let requestServerId = request.data.server.serverId; // serverId (identifiant du serveur)
    let tableId, checkId; // tableId (identifiant de table), checkId (identifiant de l’addition)
    let tId = request.terminalId;
    let mId = request.merchantId;
    let response = {};

    response = {
        'terminalId': tId,
        'merchantId': mId,
        'configCode': getCfgCode(),
        'requestId': requestId,
        'responseTimestamp': getDateTime(),
        'session': session
    }
    if (request.data.server.serverId != undefined) {
        requestServerId = request.data.server.serverId;
    } else {
        response.status = "603";
        response.statusDesc = errCodesMsgsMap[response.status];
        console.info("unable to determine the serverId", request.data.server.serverId);

        return response;
    }
    if (request.data.check.tableId != undefined) {
        tableId = request.data.check.tableId;
    } else {
        response.status = "606";
        response.statusDesc = errCodesMsgsMap[response.status];
        return response;
    }
    if (request.data.check.checkId != undefined) {
        checkId = request.data.check.checkId;
    } else {
        response.status = "608";
        response.statusDesc = errCodesMsgsMap[response.status];
        return response;
    }
    if (request.data.payment != undefined) {
        // traiter l’objet de paiement (payment)
    } else {
        response.status = "611";
        response.statusDesc = errCodesMsgsMap[response.status];
        return response;
    }
    // tous les montants doivent être vos montants réels
    response = {
        ...response,
        'status': '200',
        'statusDesc': 'OK',
        'data': {
            'check': {
                'checkId': checkId,
                'checkName': 'checkName',
                'totalAmount': 15000,
                'preTaxAmount': 14000,
                'remainingAmount': 10000
            },
            'table': {
                'tableId': tableId,
                'tableName': '0020',
                'tableTotalAmount': 15000,
                'tableRemainingAmount': 10000
            }
        }
    }
    return response;
}
let connectToRMSCloud = function (cloudSever, options) {

    console.info('connectToRMSCloud');
    // connexion TLS au cloud RMS de Moneris
    cloud_sock = tls.connect(cloudSever, options, function () {
        console.info('connected to options: ', cloudSever.host, ' port: ', cloudSever.port);
        // requête d’authentification
        let authReq = {
            action: 'authenticate',
            apiToken: getApiToken(), // votre apiToken (jeton d’API)
            cloudApiVersion: '1.0',
            merchantId: getMID(),
            requestId: getRequestId(),
            requestTimestamp: getDateTime()
        };
        console.info('send to cloud:\n ', JSON.stringify(authReq, null, 2));
        let sendbuf = twoBytesHeaderAppender(authReq);
        cloud_sock.write(sendbuf);

        cloud_sock.on('close', onClose);
        cloud_sock.on('data', onData);
        cloud_sock.on('error', onError);
        cloud_sock.on('timeout', onTimeout);
    });
}

let onClose = function () {
    // traiter si la connexion est fermée
    console.info('cloud onClose ', new Date().toString());
    stopEchoInterval(cloud_sock);
    
};


let onData = async function (dataWith2Bytes) {
    //
    let response = [], sendbuf = [];
    let [isErrored, data] = twoBytesHeaderTrimmer(dataWith2Bytes);  // convertir uniquement en JSON
    if (isErrored) {
        cloud_sock.end();
        return;
    }

    if (data.action == ActionType.echo) {
        console.info('\x1b[32m', ' rev echo:\n' + JSON.stringify(data, null, 2)); // rev echo (réception d’écho)
    } else {
        console.info('rev:\n' + JSON.stringify(data, null, 2)); // rev (réception)
    }
    let status = parseInt(data.status);
    switch (data.action) {
        case ActionType.authenticate:  // traiter la réponse à l’action authenticate (authentifier)
            let status = parseInt(data.status);
            if (status === 200) { // bon statut
                console.info('Authenticate response OK, SetInterval for sending Echo Request');
                // définir l’intervalle d’écho toutes les 30 s
                startEchoInterval(cloud_sock);
             
            } else {
                console.info('\x1b[31m', 'Authenticate response failed: ' + data.status + ' ' + 'Desc: ', data.statusDesc);
                cloud_sock.end();

            }
            break;
        case ActionType.echo:  // traiter la réponse à l’action authenticate (authentifier)

            if (cloud_sock.echoTimeout != undefined) {

                clearTimeout(cloud_sock.echoTimeout);
            }
            cloud_sock.gotEchoNoResponse = 1;
            break;
        case ActionType.getTables:  // traiter la requête d’action getTables (obtenir les tables)

            response = getTables(data);
            sendbuf = twoBytesHeaderAppender(response);
            cloud_sock.write(sendbuf);
            console.info('response on getTables:' + new Date().toString() + '\n' + JSON.stringify(response, null, 2));
            break;
        case ActionType.getTable:// traiter la requête d’action getTable (obtenir la table)

            response = getTable(data);
            sendbuf = twoBytesHeaderAppender(response);
            cloud_sock.write(sendbuf);
            console.info('response on getTables:' + new Date().toString() + '\n' + JSON.stringify(response, null, 2));
            break;
        case ActionType.applyPayment: // traiter la requête d’action applyPayment (appliquer le paiement)
            response = processPayment(data);
            sendbuf = twoBytesHeaderAppender(response);
            cloud_sock.write(sendbuf);
            console.info('response on getTables:' + new Date().toString() + '\n' + JSON.stringify(response, null, 2));
            break;
        default:

            response = {
                'terminalId': data.terminalId,
                'merchantId': data.merchantId,
                'configCode': getCfgCode(),
                'requestId': data.requestId,
                'responseTimestamp': getDateTime(),
                'session': data.session,
                'status': '218',
                'statusDesc': errCodesMsgsMap['218']
            }
            sendbuf = twoBytesHeaderAppender(response);
            cloud_sock.write(sendbuf);
            console.info('unkonwn action: \n', JSON.stringify(response, null, 2));
            break;
    }
};

let onError = function (e) {
    console.info('cloud onError', e);
    cloud_sock.destroy();
 
};


let onTimeout = function () {
    console.info('onTimeout, end session');
    cloud_sock.end();
 
};


// ajouter 2 octets de longueur de message au début
const twoBytesHeaderAppender = function (dataObject) {

    let bufContent;

    bufContent = Buffer.from(JSON.stringify(dataObject), 'utf8');

    let bufTwoBytesHeader = Buffer.alloc(2);
    bufTwoBytesHeader.writeUInt16BE(bufContent.length, 0);

    let buf = Buffer.concat([bufTwoBytesHeader, bufContent]);

    return buf;
};

// obtenir le message du cloud Moneris
const twoBytesHeaderTrimmer = function (data) {

    let isErrored = true;
    let message = '';
    if (data.length <= 2) {

        return [isErrored, message];
    }

    let dataLen = data.readUInt16BE(0);
    if (dataLen !== data.length - 2) {
        console.log(dataLen);
        console.log(data.toString());

        return [isErrored, message];
    }

    try {
        message = JSON.parse(data.slice(2).toString());
        isErrored = false;

        return [isErrored, message];
    } catch (e) {
        console.error('JSON parse error', e);
        console.error('JSON onParseError', data.toString());

        return [isErrored, message];
    }
};


/***************************************************************************
 *                              Se connecter au cloud RMS                  *
 ***************************************************************************/
connectToRMSCloud(cloudSever, options);
/*************************************************************************
 *                       Configuration des gestionnaires d’événements     *
 *************************************************************************/