trm-core
Version:
TRM (Transport Request Manager) Core
732 lines (731 loc) • 34.6 kB
JavaScript
;
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 () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__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());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Transport = exports.COMMENT_OBJ = void 0;
const logger_1 = require("../logger");
const commons_1 = require("../commons");
const node_r3trans_1 = require("node-r3trans");
const TrmTransportIdentifier_1 = require("./TrmTransportIdentifier");
const manifest_1 = require("../manifest");
const promises_1 = require("timers/promises");
const fs = __importStar(require("fs"));
const path_1 = __importDefault(require("path"));
const cliProgress = __importStar(require("cli-progress"));
const CliLogger_1 = require("../logger/CliLogger");
const CliLogFileLogger_1 = require("../logger/CliLogFileLogger");
const systemConnector_1 = require("../systemConnector");
exports.COMMENT_OBJ = 'ZTRM';
class Transport {
constructor(trkorr, _trTarget) {
this.trkorr = trkorr;
this._trTarget = _trTarget;
this._fileNames = Transport._getFileNames(trkorr, systemConnector_1.SystemConnector.getDest());
}
setTrmIdentifier(identifier) {
this.trmIdentifier = identifier;
return this;
}
getE070() {
return __awaiter(this, void 0, void 0, function* () {
if (!this._e070) {
const e070 = yield systemConnector_1.SystemConnector.readTable('E070', [{ fieldName: 'TRKORR' }, { fieldName: 'TRFUNCTION' }, { fieldName: 'AS4DATE' }, { fieldName: 'AS4TIME' }], `TRKORR EQ '${this.trkorr}'`);
if (e070.length === 1) {
this._e070 = e070[0];
}
}
return this._e070;
});
}
getE071() {
return __awaiter(this, void 0, void 0, function* () {
if (!this._e071) {
this._e071 = yield systemConnector_1.SystemConnector.readTable('E071', [{ fieldName: 'PGMID' }, { fieldName: 'OBJECT' }, { fieldName: 'OBJ_NAME' }], `TRKORR EQ '${this.trkorr}'`);
}
return this._e071;
});
}
getTasks() {
return __awaiter(this, void 0, void 0, function* () {
var tasks = [];
const sTrkorr = yield systemConnector_1.SystemConnector.readTable('E070', [{ fieldName: 'TRKORR' }], `STRKORR EQ '${this.trkorr}'`);
sTrkorr.forEach(o => {
tasks.push(new Transport(o.trkorr));
});
return tasks;
});
}
getDevclass() {
return __awaiter(this, void 0, void 0, function* () {
const aE071 = yield this.getE071();
var aDevclass = aE071.filter(o => o.pgmid === 'R3TR' && o.object === 'DEVC').map(o => o.objName);
if (!systemConnector_1.SystemConnector.getSupportedBulk().getTransportObjects) {
for (const oE071 of aE071) {
if (oE071.pgmid === 'R3TR') {
const tadir = yield systemConnector_1.SystemConnector.getObject(oE071.pgmid, oE071.object, oE071.objName);
if (!aDevclass.includes(tadir.devclass)) {
aDevclass.push(tadir.devclass);
}
}
}
}
else {
const aTadirObjects = yield systemConnector_1.SystemConnector.getTransportObjectsBulk(this.trkorr);
aDevclass = aDevclass.concat(aTadirObjects.map(o => o.devclass));
aDevclass = Array.from(new Set(aDevclass));
}
var aTdevc = [];
for (var devclass of aDevclass) {
while (devclass) {
var tdevc = aTdevc.find(o => o.devclass === devclass);
if (!tdevc) {
tdevc = yield systemConnector_1.SystemConnector.getDevclass(devclass);
aTdevc.push(tdevc);
}
devclass = tdevc.parentcl;
}
}
var rootDevclass = null;
while (aTdevc.length > 0 && !rootDevclass) {
const hierarchy = (0, commons_1.getPackageHierarchy)(aTdevc);
if (aDevclass.includes(hierarchy.devclass)) {
rootDevclass = hierarchy.devclass;
}
else {
aTdevc = aTdevc.filter(o => o.devclass !== hierarchy.devclass);
}
}
return rootDevclass;
});
}
getDate() {
return __awaiter(this, void 0, void 0, function* () {
const e070 = yield this.getE070();
return (0, commons_1.fromAbapToDate)(e070.as4Date, e070.as4Time);
});
}
isTrmRelevant() {
return __awaiter(this, void 0, void 0, function* () {
const e071 = yield this.getE071();
const trmComments = e071.filter(o => o.pgmid === '*' && o.object === exports.COMMENT_OBJ);
const hasName = trmComments.find(o => /name=/i.test(o.objName));
const hasVersion = trmComments.find(o => /version=/i.test(o.objName));
return (hasName && hasVersion) ? true : false;
});
}
download() {
return __awaiter(this, void 0, void 0, function* () {
var binaryTransport = {
header: null,
data: null
};
const filePaths = yield Transport._getFilePaths(this._fileNames);
logger_1.Logger.loading(`Reading ${this.trkorr} binary files...`, true);
binaryTransport.header = yield systemConnector_1.SystemConnector.getBinaryFile(filePaths.header);
binaryTransport.data = yield systemConnector_1.SystemConnector.getBinaryFile(filePaths.data);
logger_1.Logger.success(`${this.trkorr} file read success.`, true);
return {
binaries: binaryTransport,
filenames: this._fileNames
};
});
}
setDocumentation(sDocumentation) {
return __awaiter(this, void 0, void 0, function* () {
this._docs = undefined;
var doc = [];
const indentationSplit = sDocumentation.split('\n');
indentationSplit.forEach(s => {
if (s.length <= 67) {
doc.push({
tdformat: '/',
tdline: s
});
}
else {
const sizeLimit = s.match(/.{1,67}/g) || [];
sizeLimit.forEach(sl => {
doc.push({
tdformat: '/',
tdline: sl
});
});
}
});
logger_1.Logger.loading(`Setting ${this.trkorr} documentation...`, true);
yield systemConnector_1.SystemConnector.setTransportDoc(this.trkorr, doc);
logger_1.Logger.success(`${this.trkorr} documentation updated.`, true);
return this;
});
}
getDocumentation() {
return __awaiter(this, void 0, void 0, function* () {
if (!this._docs || this._docs.length === 0) {
logger_1.Logger.loading(`Reading ${this.trkorr} documentation...`, true);
const doktl = yield systemConnector_1.SystemConnector.readTable('DOKTL', [{ fieldName: 'LANGU' }, { fieldName: 'DOKVERSION' }, { fieldName: 'LINE' }, { fieldName: 'DOKTEXT' }], `ID EQ 'TA' AND OBJECT EQ '${this.trkorr}'`);
this._docs = Transport.doktlToDoc(doktl);
this._docs = this._docs.sort((a, b) => b.version - a.version);
logger_1.Logger.success(`Found ${this.trkorr} ${this._docs.length} documentation.`, true);
}
return this._docs;
});
}
static doktlToDoc(doktl) {
var aDocs = [];
var trkorrDoktl = [];
doktl.forEach(o => {
const version = parseInt(o.dokversion);
const lineNumber = parseInt(o.line);
var arrayIndex = trkorrDoktl.findIndex(td => td.langu === o.langu && td.version === version);
if (arrayIndex < 0) {
arrayIndex = trkorrDoktl.push({
langu: o.langu,
version,
docLines: []
});
arrayIndex--;
}
trkorrDoktl[arrayIndex].docLines.push({
no: lineNumber,
value: o.doktext
});
trkorrDoktl[arrayIndex].docLines.sort((a, b) => a.no - b.no);
});
trkorrDoktl = trkorrDoktl.sort((a, b) => a.version - b.version);
trkorrDoktl.forEach(o => {
aDocs.push({
langu: o.langu,
version: o.version,
value: o.docLines.map(o => o.value).join('')
});
});
return aDocs;
}
addObjects(objects, lock) {
return __awaiter(this, void 0, void 0, function* () {
yield systemConnector_1.SystemConnector.addToTransportRequest(this.trkorr, objects, lock);
});
}
addComment(comment) {
return __awaiter(this, void 0, void 0, function* () {
yield systemConnector_1.SystemConnector.addToTransportRequest(this.trkorr, [{
pgmid: '*',
object: exports.COMMENT_OBJ,
objName: comment
}], false);
});
}
addTranslations(aDevclass) {
return __awaiter(this, void 0, void 0, function* () {
var aDevclassLangFilter = [];
aDevclass.forEach(d => {
if (!aDevclassLangFilter.find(o => o.low === d)) {
aDevclassLangFilter.push({
sign: 'I',
option: 'EQ',
low: d
});
}
});
yield systemConnector_1.SystemConnector.addTranslationToTr(this.trkorr, aDevclassLangFilter);
});
}
getLinkedPackage() {
return __awaiter(this, void 0, void 0, function* () {
const trmRelevant = yield this.isTrmRelevant();
if (!trmRelevant) {
return;
}
var oTrmPackage;
const aDocumentation = yield this.getDocumentation();
const logonLanguage = systemConnector_1.SystemConnector.getLogonLanguage(true);
const oDocumentationLang = aDocumentation.find(o => o.langu === logonLanguage);
var docVal;
if (oDocumentationLang) {
docVal = oDocumentationLang.value;
}
else {
if (aDocumentation.length > 0) {
docVal = aDocumentation[0].value;
}
}
try {
oTrmPackage = manifest_1.Manifest.fromAbapXml(docVal).setLinkedTransport(this).getPackage();
}
catch (e) {
}
try {
oTrmPackage.setDevclass(yield this.getDevclass());
}
catch (e) {
}
return oTrmPackage;
});
}
delete() {
return __awaiter(this, void 0, void 0, function* () {
yield systemConnector_1.SystemConnector.deleteTrkorr(this.trkorr);
return null;
});
}
release(lock, skipLog, tmpFolder, secondsTimeout) {
return __awaiter(this, void 0, void 0, function* () {
var rc;
logger_1.Logger.loading('Releasing transport...', skipLog);
yield systemConnector_1.SystemConnector.releaseTrkorr(this.trkorr, lock, secondsTimeout);
yield systemConnector_1.SystemConnector.dequeueTransport(this.trkorr);
if (tmpFolder) {
rc = yield this.readReleaseLog(tmpFolder, secondsTimeout);
}
else {
rc = yield this._isInTmsQueue(skipLog, false, secondsTimeout);
}
if (!skipLog && !tmpFolder) {
switch (rc) {
case 4:
logger_1.Logger.warning(`${this.trkorr} release ended with warning.`);
break;
case 8:
logger_1.Logger.error(`${this.trkorr} release ended with error.`);
break;
case 12:
logger_1.Logger.error(`${this.trkorr} release was cancelled.`);
break;
case 16:
logger_1.Logger.error(`${this.trkorr} release was cancelled.`);
break;
}
}
});
}
readReleaseLog(tmpFolder, secondsTimeout) {
return __awaiter(this, void 0, void 0, function* () {
const filePaths = yield Transport._getFilePaths(this._fileNames);
const localPath = path_1.default.join(tmpFolder, this._fileNames.releaseLog);
const systemR3transVersion = yield systemConnector_1.SystemConnector.getR3transVersion();
const systemR3transUnicode = yield systemConnector_1.SystemConnector.getR3transUnicode();
logger_1.Logger.log(`System R3trans: ${systemR3transVersion}`, true);
logger_1.Logger.log(`System R3trans unicode: ${systemR3transUnicode}`, true);
if (logger_1.Logger.logger instanceof CliLogger_1.CliLogger || logger_1.Logger.logger instanceof CliLogFileLogger_1.CliLogFileLogger) {
logger_1.Logger.logger.forceStop();
}
const multibar = new cliProgress.MultiBar({
clearOnComplete: true,
hideCursor: true,
format: '> {stage} [{bar}] {exitCode} {result} '
}, cliProgress.Presets.legacy);
var iEtp182 = 0;
var iEtp183 = 0;
var iEtp150 = 0;
const etp182 = multibar.create(100, iEtp182, {
stage: '',
exitCode: '',
result: 'Needs update'
});
const etp183 = multibar.create(100, iEtp183, {
stage: '',
exitCode: '',
result: 'Needs update'
});
const etp150 = multibar.create(100, iEtp150, {
stage: '',
exitCode: '',
result: 'Needs update'
});
const timeoutDate = new Date((new Date()).getTime() + (secondsTimeout * 1000));
var exitWhile = false;
var whileResult = null;
while (!exitWhile && (new Date()).getTime() < timeoutDate.getTime()) {
var logResult = [];
try {
const logBinary = yield systemConnector_1.SystemConnector.getBinaryFile(filePaths.releaseLog);
fs.writeFileSync(localPath, logBinary);
logResult = yield (new node_r3trans_1.R3transLogParser(localPath, systemR3transUnicode)).getReleaseLog();
fs.unlinkSync(localPath);
}
catch (e) {
logResult = [];
}
var etp182LogResult = logResult.find(o => o.id === 'ETP182') || { name: 'CHECK WRITEABILITY OF BUFFERS', exitCode: null };
var etp183LogResult = logResult.find(o => o.id === 'ETP183') || { name: 'EXPORT PREPARATION', exitCode: null };
var etp150LogResult = logResult.find(o => o.id === 'ETP150') || { name: 'MAIN EXPORT', exitCode: null };
etp183LogResult.name += ' ';
etp150LogResult.name += ' ';
const etp182ExitCode = node_r3trans_1.R3transLogParser.parseExitCode(etp182LogResult.exitCode);
const etp183ExitCode = node_r3trans_1.R3transLogParser.parseExitCode(etp183LogResult.exitCode);
const etp150ExitCode = node_r3trans_1.R3transLogParser.parseExitCode(etp150LogResult.exitCode);
exitWhile = (etp182LogResult.exitCode !== null) && (etp183LogResult.exitCode !== null) && (etp150LogResult.exitCode !== null);
if (etp182ExitCode.type === 'SUCCESS' || etp183ExitCode.type === 'SUCCESS' || etp150ExitCode.type === 'SUCCESS') {
whileResult = 'SUCCESS';
}
if (etp182ExitCode.type === 'WARNING' || etp183ExitCode.type === 'WARNING' || etp150ExitCode.type === 'WARNING') {
whileResult = 'WARNING';
}
if (etp182ExitCode.type === 'ERROR' || etp183ExitCode.type === 'ERROR' || etp150ExitCode.type === 'ERROR') {
whileResult = 'ERROR';
}
const etp182Payload = {
stage: etp182LogResult.name,
exitCode: etp182LogResult.exitCode || '',
result: etp182ExitCode.type !== 'UNKNOWN' ? etp182ExitCode.value : 'In progress'
};
const etp183Payload = {
stage: etp183LogResult.name,
exitCode: etp183LogResult.exitCode || '',
result: etp183ExitCode.type !== 'UNKNOWN' ? etp183ExitCode.value : 'In progress'
};
const etp150Payload = {
stage: etp150LogResult.name,
exitCode: etp150LogResult.exitCode || '',
result: etp150ExitCode.type !== 'UNKNOWN' ? etp150ExitCode.value : 'In progress'
};
if (iEtp182 < 99) {
if (etp182ExitCode.type === 'UNKNOWN') {
iEtp182++;
}
else {
iEtp182 = 100;
}
}
else {
if (etp182ExitCode.type === 'UNKNOWN') {
iEtp182++;
}
}
etp182.update(iEtp182, etp182Payload);
if (iEtp183 < 99) {
if (etp183ExitCode.type === 'UNKNOWN') {
iEtp183++;
}
else {
iEtp183 = 100;
}
}
else {
if (etp183ExitCode.type === 'UNKNOWN') {
iEtp183++;
}
}
etp183.update(iEtp183, etp183Payload);
if (iEtp150 < 99) {
if (etp150ExitCode.type === 'UNKNOWN') {
iEtp150++;
}
else {
iEtp150 = 100;
}
}
else {
if (etp150ExitCode.type === 'UNKNOWN') {
iEtp150++;
}
}
etp150.update(iEtp150, etp150Payload);
yield (0, promises_1.setTimeout)(1000);
}
multibar.stop();
var error;
var rc;
if (!exitWhile) {
error = new Error(`Timed out waiting for release.`);
}
else {
if (whileResult === "ERROR") {
error = new Error(`Error occurred during transport ${this.trkorr} release.`);
}
if (whileResult === "SUCCESS") {
logger_1.Logger.success(`Transport ${this.trkorr} released with success.`);
rc = 0;
}
if (whileResult === "WARNING") {
logger_1.Logger.warning(`Transport ${this.trkorr} released with warning.`);
rc = 4;
}
}
if (error) {
throw error;
}
else {
return rc;
}
});
}
readImportLog(tmpFolder) {
return __awaiter(this, void 0, void 0, function* () {
});
}
_isInTmsQueue(skipLog_1) {
return __awaiter(this, arguments, void 0, function* (skipLog, checkImpSing = false, secondsTimeout) {
const timeoutDate = new Date((new Date()).getTime() + (secondsTimeout * 1000));
logger_1.Logger.log(`TMS check for transport ${this.trkorr}, timeout date set to ${timeoutDate}`, true);
var inQueue = false;
var rc = 12;
if (this._trTarget) {
var sLog = `status unknown`;
var inQueueAttempts = 0;
while (!inQueue && (new Date()).getTime() < timeoutDate.getTime()) {
inQueueAttempts++;
logger_1.Logger.log(`Attempt ${inQueueAttempts}`, true);
logger_1.Logger.loading(`Reading transport queue...`, skipLog);
yield (0, promises_1.setTimeout)(6000);
var tmsQueue = yield systemConnector_1.SystemConnector.readTmsQueue(this._trTarget);
tmsQueue = tmsQueue.filter(o => o.trkorr === this.trkorr);
tmsQueue = tmsQueue.sort((a, b) => parseInt(b.bufpos) - parseInt(a.bufpos));
if (!checkImpSing) {
sLog = `released`;
inQueue = tmsQueue.length > 0;
}
else {
sLog = `imported`;
if (tmsQueue.length > 0) {
inQueue = tmsQueue[0].impsing !== 'X';
rc = parseInt(tmsQueue[0].maxrc);
}
else {
inQueue = false;
}
}
}
if (!inQueue) {
throw new Error(`Transport request not found in queue, timed out after ${inQueueAttempts + 1} attempts`);
}
else {
logger_1.Logger.success(`Transport ${this.trkorr} ${sLog}.`, skipLog);
}
}
else {
logger_1.Logger.error(`No target specified, unable to check queue!!`, true);
}
return rc;
});
}
static _getFileNames(trkorr, targetSystem) {
const trkorrRegex = /(\S{3})K(.*)/gi;
const regexIterator = trkorr.matchAll(trkorrRegex);
var trkorrFileExtension;
var trkorrNumber;
try {
const matches = regexIterator.next().value;
trkorrFileExtension = matches[1];
trkorrNumber = matches[2];
}
catch (e) {
throw new Error(`Couldn't parse transport ${trkorr}.`);
}
return {
header: `K${trkorrNumber}.${trkorrFileExtension}`,
data: `R${trkorrNumber}.${trkorrFileExtension}`,
releaseLog: `${trkorrFileExtension}E${trkorrNumber}.${trkorrFileExtension}`,
importLogH: `${trkorrFileExtension}H${trkorrNumber}.${targetSystem}`,
importLogA: `${trkorrFileExtension}A${trkorrNumber}.${targetSystem}`,
importLogI: `${trkorrFileExtension}I${trkorrNumber}.${targetSystem}`,
importLogV: `${trkorrFileExtension}V${trkorrNumber}.${targetSystem}`,
importLogR: `${trkorrFileExtension}R${trkorrNumber}.${targetSystem}`,
importLogG: `${trkorrFileExtension}G${trkorrNumber}.${targetSystem}`
};
}
static _getFilePaths(fileNames) {
return __awaiter(this, void 0, void 0, function* () {
logger_1.Logger.loading(`Reading system data...`, true);
const dirTrans = yield systemConnector_1.SystemConnector.getDirTrans();
const fileSys = yield systemConnector_1.SystemConnector.getFileSystem();
const pathSeparator = (0, commons_1.getFileSysSeparator)(fileSys.filesys);
logger_1.Logger.success(`Data read success.`, true);
return {
header: `${dirTrans}${pathSeparator}cofiles${pathSeparator}${fileNames.header}`,
data: `${dirTrans}${pathSeparator}data${pathSeparator}${fileNames.data}`,
releaseLog: `${dirTrans}${pathSeparator}log${pathSeparator}${fileNames.releaseLog}`,
importLogH: `${dirTrans}${pathSeparator}log${pathSeparator}${fileNames.importLogH}`,
importLogA: `${dirTrans}${pathSeparator}log${pathSeparator}${fileNames.importLogA}`,
importLogI: `${dirTrans}${pathSeparator}log${pathSeparator}${fileNames.importLogI}`,
importLogV: `${dirTrans}${pathSeparator}log${pathSeparator}${fileNames.importLogV}`,
importLogR: `${dirTrans}${pathSeparator}log${pathSeparator}${fileNames.importLogR}`,
importLogG: `${dirTrans}${pathSeparator}log${pathSeparator}${fileNames.importLogG}`
};
});
}
static createToc(data) {
return __awaiter(this, void 0, void 0, function* () {
logger_1.Logger.loading(`Creating transport request (TOC)...`, true);
const trkorr = yield systemConnector_1.SystemConnector.createTocTransport(data.text, data.target);
logger_1.Logger.success(`Transport request ${trkorr} generated successfully.`, true);
return new Transport(trkorr, data.target).setTrmIdentifier(data.trmIdentifier);
});
}
static createLang(data) {
return __awaiter(this, void 0, void 0, function* () {
logger_1.Logger.loading(`Creating transport request (LANG)...`, true);
const trkorr = yield systemConnector_1.SystemConnector.createWbTransport(data.text, data.target);
logger_1.Logger.success(`Transport request ${trkorr} generated successfully.`, true);
return new Transport(trkorr, data.target).setTrmIdentifier(TrmTransportIdentifier_1.TrmTransportIdentifier.LANG);
});
}
static createWb(data) {
return __awaiter(this, void 0, void 0, function* () {
logger_1.Logger.loading(`Creating transport request (WB)...`, true);
const trkorr = yield systemConnector_1.SystemConnector.createWbTransport(data.text, data.target);
logger_1.Logger.success(`Transport request ${trkorr} generated successfully.`, true);
return new Transport(trkorr, null);
});
}
static getContent(data, r3transOption) {
return __awaiter(this, void 0, void 0, function* () {
const r3trans = new node_r3trans_1.R3trans(r3transOption);
const trkorr = yield r3trans.getTransportTrkorr(data);
var transportContent = {
trkorr,
tdevc: [],
tdevct: [],
tadir: []
};
transportContent.tdevc = yield r3trans.getTableEntries(data, 'TDEVC');
transportContent.tdevct = yield r3trans.getTableEntries(data, 'TDEVCT');
transportContent.tadir = yield r3trans.getTableEntries(data, 'TADIR');
return transportContent;
});
}
static upload(data) {
return __awaiter(this, void 0, void 0, function* () {
logger_1.Logger.loading(`Reading binary content...`, true);
const fileContent = yield Transport.getContent(data.binary.data, data.r3transOption);
const trkorr = fileContent.trkorr;
logger_1.Logger.success(`Transport ${trkorr} read success.`, true);
const fileNames = Transport._getFileNames(trkorr, systemConnector_1.SystemConnector.getDest());
const filePaths = yield Transport._getFilePaths(fileNames);
logger_1.Logger.loading(`Uploading ${trkorr} header to "${filePaths.header}"...`, true);
yield systemConnector_1.SystemConnector.writeBinaryFile(filePaths.header, data.binary.header);
logger_1.Logger.success(`Header uploaded successfully.`, true);
logger_1.Logger.loading(`Uploading ${trkorr} data to "${filePaths.data}"...`, true);
yield systemConnector_1.SystemConnector.writeBinaryFile(filePaths.data, data.binary.data);
logger_1.Logger.success(`Data uploaded successfully.`, true);
logger_1.Logger.success(`Transport request ${trkorr} uploaded successfully.`, true);
return new Transport(trkorr, data.trTarget);
});
}
static getTransportsFromObject(objectKeys) {
return __awaiter(this, void 0, void 0, function* () {
var transports = [];
const aSkipTrkorr = yield systemConnector_1.SystemConnector.getIgnoredTrkorr();
const objectInTransport = (yield systemConnector_1.SystemConnector.readTable('E071', [{ fieldName: 'TRKORR' }], `PGMID EQ '${objectKeys.pgmid.trim().toUpperCase()}' AND OBJECT EQ '${objectKeys.object.trim().toUpperCase()}' AND OBJ_NAME EQ '${objectKeys.objName.trim().toUpperCase()}'`)).map(o => o.trkorr).filter(trkorr => !aSkipTrkorr.includes(trkorr));
for (const trkorr of objectInTransport) {
try {
const oTransport = new Transport(trkorr);
const e070 = yield oTransport.getE070();
if (e070.trfunction !== 'K' && e070.trfunction !== 'S' && e070.trfunction !== 'R' && e070.trfunction !== 'T') {
throw new Error(`Unexpected TRFUNCTION for transport ${trkorr}: ${e070.trfunction}`);
}
transports.push(oTransport);
}
catch (e) {
logger_1.Logger.error(`Transport instance skip for ${trkorr}: ${e.toString()}`, true);
}
}
return transports;
});
}
static getLatest(transports) {
return __awaiter(this, void 0, void 0, function* () {
var latest;
for (const transport of transports) {
if (!latest) {
latest = transport;
}
else {
if ((yield transport.getDate()) > (yield latest.getDate())) {
latest = transport;
}
}
}
return latest;
});
}
import() {
return __awaiter(this, arguments, void 0, function* (timeout = 180) {
if (!this._trTarget) {
throw new Error('Missing transport target.');
}
logger_1.Logger.log(`Starting transport ${this.trkorr} import, timeout set to ${timeout}`, true);
logger_1.Logger.loading(`Forwarding transport ${this.trkorr}`, true);
yield systemConnector_1.SystemConnector.forwardTransport(this.trkorr, this._trTarget, this._trTarget, true);
logger_1.Logger.loading(`Importing transport ${this.trkorr}`, true);
yield systemConnector_1.SystemConnector.importTransport(this.trkorr, this._trTarget);
logger_1.Logger.log(`Starting transport ${this.trkorr} TMS queue status check`, true);
const rc = yield this._isInTmsQueue(false, true, timeout);
logger_1.Logger.log(`Transport ${this.trkorr} import ended: return code ${rc}`, true);
switch (rc) {
case 4:
logger_1.Logger.warning(`${this.trkorr} import ended with warning.`);
break;
case 8:
logger_1.Logger.error(`${this.trkorr} import ended with error.`);
break;
case 12:
logger_1.Logger.error(`${this.trkorr} import was cancelled.`);
break;
case 16:
logger_1.Logger.error(`${this.trkorr} import was cancelled.`);
break;
}
});
}
rename(as4text) {
return __awaiter(this, void 0, void 0, function* () {
yield systemConnector_1.SystemConnector.renameTransportRequest(this.trkorr, as4text);
});
}
canBeDeleted() {
return __awaiter(this, void 0, void 0, function* () {
const status = yield systemConnector_1.SystemConnector.getTransportStatus(this.trkorr);
return status === 'D';
});
}
addObjectsFromTransport(from) {
return __awaiter(this, void 0, void 0, function* () {
yield systemConnector_1.SystemConnector.trCopy(from, this.trkorr, false);
});
}
}
exports.Transport = Transport;