trm-core 4.1.4 → 6.0.0

package/dist/client/RESTClient.js

@@ -0,0 +1,499 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESTClient = void 0;
+const commons_1 = require("../commons");
+const FormData = __importStar(require("form-data"));
+const logger_1 = require("../logger");
+const AXIOS_CTX = "RestServer";
+class RESTClient {
+    constructor(endpoint, rfcdest, _login, _cLangu) {
+        this.endpoint = endpoint;
+        this.rfcdest = rfcdest;
+        this._login = _login;
+        this._cLangu = _cLangu;
+        this._connected = false;
+        this.endpoint = this.endpoint.trim();
+        this._axiosInstance = (0, commons_1.getAxiosInstance)({
+            baseURL: this.endpoint,
+            auth: {
+                username: this._login.user,
+                password: this._login.passwd
+            },
+            timeout: 10000,
+        }, AXIOS_CTX);
+    }
+    open() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._connected) {
+                const response = yield this._axiosInstance.get('/', {
+                    timeout: 5000
+                });
+                if (response.status !== 200) {
+                    throw new Error(`Couldn't reach ${this.endpoint}!`);
+                }
+                else {
+                    this._connected = true;
+                    this._axiosInstance.interceptors.response.use((response) => {
+                        return response;
+                    }, (error) => __awaiter(this, void 0, void 0, function* () {
+                        var axiosError;
+                        if (error.name === `Trm${AXIOS_CTX}Error`) {
+                            axiosError = error.axiosError;
+                        }
+                        else {
+                            axiosError = error;
+                        }
+                        if (axiosError.config.url === '/read_table') {
+                            if (JSON.parse(axiosError.config.data).query_table === 'T100') {
+                                throw error;
+                            }
+                        }
+                        var message;
+                        var messageError;
+                        try {
+                            message = yield this.getMessage({
+                                no: `${axiosError.response.data.message.msgno}`,
+                                class: axiosError.response.data.message.msgid,
+                                v1: axiosError.response.data.message.msgv1,
+                                v2: axiosError.response.data.message.msgv2,
+                                v3: axiosError.response.data.message.msgv3,
+                                v4: axiosError.response.data.message.msgv4
+                            });
+                        }
+                        catch (k) {
+                            messageError = k;
+                            message = `Couldn't read error message ${axiosError.response.data.message.abapMsgClass} ${axiosError.response.data.message.abapMsgNumber} ${axiosError.response.data.message.abapMsgV1} ${axiosError.response.data.message.abapMsgV2} ${axiosError.response.data.message.abapMsgV3} ${axiosError.response.data.message.abapMsgV4}`;
+                        }
+                        var rfcClientError = new Error(message.trim());
+                        rfcClientError.name = 'TrmRESTClient';
+                        rfcClientError.restError = axiosError;
+                        if (messageError) {
+                            rfcClientError.messageError = messageError;
+                        }
+                        if (axiosError.response.data.log) {
+                            rfcClientError.messageLog = axiosError.response.data.log;
+                        }
+                        logger_1.Logger.error(rfcClientError.toString(), true);
+                        throw rfcClientError;
+                    }));
+                }
+            }
+        });
+    }
+    checkConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._connected;
+        });
+    }
+    getMessage(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var msgnr = data.no;
+            while (msgnr.length < 3) {
+                msgnr = `0${msgnr}`;
+            }
+            const aT100 = yield this.readTable('T100', [{ fieldName: 'SPRSL' }, { fieldName: 'ARBGB' }, { fieldName: 'MSGNR' }, { fieldName: 'TEXT' }], `SPRSL EQ '${this._cLangu}' AND ARBGB EQ '${data.class}' AND MSGNR EQ '${msgnr}'`);
+            if (aT100.length === 1 && aT100[0].text) {
+                var msg = aT100[0].text;
+                msg = msg.replace("&1", data.v1 || '');
+                msg = msg.replace("&2", data.v2 || '');
+                msg = msg.replace("&3", data.v3 || '');
+                msg = msg.replace("&4", data.v4 || '');
+                return msg.trim();
+            }
+            else {
+                throw new Error(`Message ${msgnr}, class ${data.class}, lang ${this._cLangu} not found.`);
+            }
+        });
+    }
+    readTable(tableName, fields, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var sqlOutput = [];
+            const delimiter = '|';
+            var aOptions = [];
+            if (options) {
+                const aSplit = options.split(/\s+AND\s+/);
+                if (aSplit.length > 1) {
+                    aSplit.forEach((s, i) => {
+                        var sText = s.trim();
+                        if (i !== 0) {
+                            sText = `AND ${sText}`;
+                        }
+                        aOptions.push({ text: sText });
+                    });
+                }
+                else {
+                    aOptions = aSplit.map(s => {
+                        return {
+                            text: s
+                        };
+                    });
+                }
+            }
+            const result = yield this._axiosInstance.get('/read_table', {
+                params: {
+                    rfcdest: this.rfcdest
+                },
+                data: {
+                    query_table: tableName.toUpperCase(),
+                    delimiter,
+                    options: aOptions,
+                    fields: fields
+                }
+            });
+            const data = result.data;
+            data.forEach(tab512 => {
+                var sqlLine = {};
+                const waSplit = tab512.wa.split(delimiter);
+                fields.forEach((field, index) => {
+                    sqlLine[field.fieldName] = waSplit[index].trim();
+                });
+                sqlOutput.push(sqlLine);
+            });
+            return (0, commons_1.normalize)(sqlOutput);
+        });
+    }
+    getFileSystem() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/get_file_sys')).data;
+            return result.fileSys;
+        });
+    }
+    getDirTrans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/get_dir_trans')).data;
+            return result.dirTrans;
+        });
+    }
+    getBinaryFile(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/get_binary_file', {
+                responseType: 'arraybuffer',
+                headers: {
+                    'Content-Type': 'application/octet-stream'
+                },
+                data: {
+                    file_path: filePath
+                }
+            })).data;
+            return result;
+        });
+    }
+    writeBinaryFile(filePath, binary) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formData = new FormData.default();
+            var filename;
+            try {
+                filename = /[^\\\/]+$/gmi.exec(filePath)[0];
+            }
+            catch (e) {
+                filename = 'UNKNOWN_FILENAME';
+            }
+            formData.append('file', binary, filename);
+            formData.append('file_path', filePath);
+            yield this._axiosInstance.post('/write_binary_file', formData, {
+                headers: formData.getHeaders()
+            });
+        });
+    }
+    createTocTransport(text, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.post('/create_toc', {
+                text: text,
+                target: target.trim().toUpperCase()
+            })).data;
+            return result.trkorr;
+        });
+    }
+    createWbTransport(text, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.post('/create_import_tr', {
+                text: text,
+                target: target.trim().toUpperCase()
+            })).data;
+            return result.trkorr;
+        });
+    }
+    setTransportDoc(trkorr, doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.put('/set_transport_doc', {
+                trkorr: trkorr.trim().toUpperCase(),
+                doc: doc
+            });
+        });
+    }
+    getDevclassObjects(devclass) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/get_devclass_objs', {
+                data: {
+                    devclass: devclass.trim().toUpperCase()
+                }
+            })).data;
+            return result.tadir;
+        });
+    }
+    addToTransportRequest(trkorr, content, lock) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.put('/add_objs_tr', {
+                lock: lock ? 'X' : ' ',
+                trkorr: trkorr.trim().toUpperCase(),
+                e071: content.map(o => {
+                    return {
+                        pgmid: o.pgmid,
+                        object: o.object,
+                        obj_name: o.objName
+                    };
+                })
+            });
+        });
+    }
+    repositoryEnvironment(objectType, objectName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/repository_environment', {
+                params: {
+                    rfcdest: this.rfcdest
+                },
+                data: {
+                    obj_type: objectType.trim().toUpperCase(),
+                    object_name: objectName.trim().toUpperCase()
+                }
+            })).data;
+            return result.environmentTab;
+        });
+    }
+    deleteTrkorr(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.delete('/delete_transport', {
+                data: {
+                    trkorr: trkorr.trim().toUpperCase()
+                }
+            });
+        });
+    }
+    releaseTrkorr(trkorr, lock, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.post('/release_tr', {
+                trkorr: trkorr.trim().toUpperCase(),
+                lock: lock ? 'X' : ' '
+            }, {
+                timeout: timeout * 1000
+            });
+        });
+    }
+    addSkipTrkorr(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.put('/add_skip_trkorr', {
+                trkorr: trkorr.trim().toUpperCase()
+            });
+        });
+    }
+    addSrcTrkorr(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.put('/add_src_trkorr', {
+                trkorr: trkorr.trim().toUpperCase()
+            });
+        });
+    }
+    readTmsQueue(target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/read_tms_queue', {
+                data: {
+                    target: target
+                }
+            })).data;
+            return result.requests;
+        });
+    }
+    createPackage(scompkdtln) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.post('/create_package', scompkdtln);
+        });
+    }
+    tdevcInterface(devclass, parentcl, rmParentCl, devlayer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.post('/tdevc_interface', {
+                devclass: devclass.trim().toUpperCase(),
+                parentcl: parentcl ? parentcl.trim().toUpperCase() : '',
+                rm_parentcl: rmParentCl ? 'X' : ' ',
+                devlayer: devlayer ? devlayer.trim().toUpperCase() : ''
+            });
+        });
+    }
+    getDefaultTransportLayer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/get_transport_layer')).data;
+            return result.layer;
+        });
+    }
+    tadirInterface(tadir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.post('/tadir_interface', {
+                pgmid: tadir.pgmid,
+                object: tadir.object,
+                obj_name: tadir.objName,
+                devclass: tadir.devclass,
+                set_genflag: tadir.genflag ? 'X' : ' ',
+                srcsystem: tadir.srcsystem
+            });
+        });
+    }
+    dequeueTransport(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.post('/dequeue_tr', {
+                trkorr: trkorr.trim().toUpperCase()
+            });
+        });
+    }
+    forwardTransport(trkorr_1, target_1, source_1) {
+        return __awaiter(this, arguments, void 0, function* (trkorr, target, source, importAgain = true) {
+            yield this._axiosInstance.post('/forward_tr', {
+                trkorr: trkorr.trim().toUpperCase(),
+                target: target.trim().toUpperCase(),
+                source: source.trim().toUpperCase(),
+                import_again: importAgain ? 'X' : ' '
+            });
+        });
+    }
+    importTransport(trkorr, system) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.post('/import_tr', {
+                system: system.trim().toUpperCase(),
+                trkorr: trkorr.trim().toUpperCase()
+            });
+        });
+    }
+    setInstallDevc(installDevc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.put('/set_install_devc', {
+                installdevc: installDevc
+            });
+        });
+    }
+    getObjectsList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/list_object_types')).data;
+            return result.objectText;
+        });
+    }
+    getTrmServerVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/version')).data;
+            return result.version;
+        });
+    }
+    trmServerPing() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/ping')).data;
+            return result.return;
+        });
+    }
+    renameTransportRequest(trkorr, as4text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.post('/rename_transport_request', {
+                trkorr: trkorr.trim().toUpperCase(),
+                as4text: as4text
+            });
+        });
+    }
+    setPackageIntegrity(integrity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.put('/set_integrity', {
+                integrity: integrity
+            });
+        });
+    }
+    addTranslationToTr(trkorr, devclassFilter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.put('/add_lang_tr', {
+                trkorr: trkorr,
+                devclass: devclassFilter
+            });
+        });
+    }
+    trCopy(from_1, to_1) {
+        return __awaiter(this, arguments, void 0, function* (from, to, doc = false) {
+            yield this._axiosInstance.post('/tr_copy', {
+                from: from,
+                to: to,
+                doc: doc ? 'X' : ' '
+            });
+        });
+    }
+    getDest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/get_dest', {
+                params: {
+                    rfcdest: this.rfcdest
+                }
+            })).data;
+            return result.dest;
+        });
+    }
+    getTransportObjectsBulk(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/get_transport_objs_bulk', {
+                data: {
+                    trkorr
+                }
+            })).data;
+            return result.tadir;
+        });
+    }
+    getExistingObjectsBulk(objects) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/get_existing_objs_bulk', {
+                data: {
+                    objects
+                }
+            })).data;
+            return result.tadir;
+        });
+    }
+    addNamespace(namespace, replicense, texts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._axiosInstance.put('/add_namespace', {
+                namespace,
+                replicense,
+                texts
+            });
+        });
+    }
+    getR3transInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = (yield this._axiosInstance.get('/get_r3trans_info')).data;
+            return result.log;
+        });
+    }
+}
+exports.RESTClient = RESTClient;

package/dist/client/RFCClient.d.ts

@@ -1,14 +1,20 @@
-/// <reference types="node" />
 import * as components from "./components";
 import * as struct from "./struct";
 import { IClient } from "./IClient";
+import { SapMessage } from ".";
 export declare class RFCClient implements IClient {
+    private _rfcClientArgs;
+    private _cLangu;
     private _rfcClient;
     private _aliveCheck;
-    constructor(arg1: any, traceDir?: string);
+    constructor(_rfcClientArgs: any, _cLangu: string, traceDir?: string);
+    private getRfcClient;
     open(): Promise<void>;
     checkConnection(): Promise<boolean>;
     private _call;
+    private _getMessage;
+    getMessage(data: SapMessage): Promise<string>;
+    private _readTable;
     readTable(tableName: components.TABNAME, fields: struct.RFC_DB_FLD[], options?: string): Promise<any[]>;
     getFileSystem(): Promise<struct.FILESYS>;
     getDirTrans(): Promise<components.PFEVALUE>;
@@ -26,7 +32,7 @@ export declare class RFCClient implements IClient {
     addSrcTrkorr(trkorr: components.TRKORR): Promise<void>;
     readTmsQueue(target: components.TMSSYSNAM): Promise<struct.STMSIQREQ[]>;
     createPackage(scompkdtln: struct.SCOMPKDTLN): Promise<void>;
-    tdevcInterface(devclass: components.DEVCLASS, parentcl?: components.DEVCLASS, rmParentCl?: boolean): Promise<void>;
+    tdevcInterface(devclass: components.DEVCLASS, parentcl?: components.DEVCLASS, rmParentCl?: boolean, devlayer?: components.DEVLAYER): Promise<void>;
     getDefaultTransportLayer(): Promise<components.DEVLAYER>;
     tadirInterface(tadir: struct.TADIR): Promise<void>;
     dequeueTransport(trkorr: components.TRKORR): Promise<void>;
@@ -40,4 +46,6 @@ export declare class RFCClient implements IClient {
     setPackageIntegrity(integrity: struct.ZTRM_INTEGRITY): Promise<void>;
     addTranslationToTr(trkorr: components.TRKORR, devclassFilter: struct.LXE_TT_PACKG_LINE[]): Promise<void>;
     trCopy(from: components.TRKORR, to: components.TRKORR, doc?: boolean): Promise<void>;
+    addNamespace(namespace: components.NAMESPACE, replicense: components.TRNLICENSE, texts: struct.TRNSPACETT[]): Promise<void>;
+    getR3transInfo(): Promise<string>;
 }