trm-core 4.1.4 → 6.0.0

package/dist/actions/install/checkTransports.js

@@ -12,14 +12,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkTransports = void 0;
 const logger_1 = require("../../logger");
 const transport_1 = require("../../transport");
+const commons_1 = require("../../commons");
+const inquirer_1 = require("../../inquirer");
 exports.checkTransports = {
     name: 'check-transports',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const packageName = context.parsedInput.packageName;
-        const r3trans = context.runtime.r3trans;
-        const oArtifact = context.runtime.trmArtifact;
-        logger_1.Logger.loading(`Reading transports...`);
-        const aTransports = yield oArtifact.getTransportBinaries();
+        logger_1.Logger.log('Check transports step', true);
+        logger_1.Logger.loading(`Checking package transports...`);
+        const aTransports = yield context.runtime.remotePackageData.artifact.getTransportBinaries();
         logger_1.Logger.log(`Package content: ${aTransports.map(o => {
             return {
                 trkorr: o.trkorr,
@@ -27,12 +27,13 @@ exports.checkTransports = {
             };
         })}`, true);
         for (const transport of aTransports) {
-            try {
-                yield r3trans.isTransportValid(transport.binaries.data);
+            const valid = yield context.runtime.r3trans.isTransportValid(transport.binaries.data);
+            if (valid) {
                 logger_1.Logger.log(`Transport ${transport.trkorr} is valid.`, true);
             }
-            catch (e) {
-                throw new Error(`Package contains invalid transport.`);
+            else {
+                logger_1.Logger.error(`Transport ${transport.trkorr} is invalid.`, true);
+                throw new Error(`Package contains invalid transports`);
             }
         }
         const aDevcTransports = aTransports.filter(o => o.type === transport_1.TrmTransportIdentifier.DEVC);
@@ -40,32 +41,80 @@ exports.checkTransports = {
         const aLangTransports = aTransports.filter(o => o.type === transport_1.TrmTransportIdentifier.LANG);
         const aCustTransports = aTransports.filter(o => o.type === transport_1.TrmTransportIdentifier.CUST);
         if (aDevcTransports.length !== 1) {
-            throw new Error(`Unexpected declaration of devclass in package ${packageName}.`);
+            logger_1.Logger.error(`Zero or multiple DEVC transports found`, true);
+            throw new Error(`Unexpected content in package.`);
         }
         else {
-            context.runtime.devcTransport = aDevcTransports[0];
-            logger_1.Logger.log(`DEVC transport is ${aDevcTransports[0].trkorr}.`, true);
+            context.runtime.packageTransports.devc.binaries = aDevcTransports[0];
+            logger_1.Logger.log(`DEVC transport is ${context.runtime.packageTransports.devc.binaries.trkorr}.`, true);
         }
-        if (aTadirTransports.length > 0) {
-            if (aTadirTransports.length !== 1) {
-                throw new Error(`Unexpected declaration of objects in package ${packageName}.`);
-            }
-            context.runtime.tadirTransport = aTadirTransports[0];
-            logger_1.Logger.log(`TADIR transport is ${aTadirTransports[0].trkorr}.`, true);
+        if (aTadirTransports.length !== 1) {
+            logger_1.Logger.error(`Zero or multiple TADIR transports found`, true);
+            throw new Error(`Unexpected content in package.`);
+        }
+        else {
+            context.runtime.packageTransports.tadir.binaries = aTadirTransports[0];
+            logger_1.Logger.log(`TADIR transport is ${context.runtime.packageTransports.tadir.binaries.trkorr}.`, true);
+            const tadirE071 = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.tadir.binaries.binaries.data, 'E071'));
+            logger_1.Logger.log(`TADIR E071: ${JSON.stringify(tadirE071)}`, true);
+            context.runtime.packageTransportsData.e071 = context.runtime.packageTransportsData.e071.concat(tadirE071);
         }
         if (aLangTransports.length > 0) {
-            if (aLangTransports.length !== 1) {
-                throw new Error(`Unexpected declaration of translations in package ${packageName}.`);
+            if (context.rawInput.installData.import.noLang === undefined) {
+                if (!context.rawInput.contextData.noInquirer) {
+                    context.rawInput.installData.import.noLang = !(yield inquirer_1.Inquirer.prompt({
+                        type: `confirm`,
+                        name: `noLang`,
+                        message: `Import language translations transport?`,
+                        default: true,
+                    })).noLang;
+                }
+            }
+            if (!context.rawInput.installData.import.noLang) {
+                if (aLangTransports.length !== 1) {
+                    logger_1.Logger.error(`Multiple LANG transports found`, true);
+                    throw new Error(`Unexpected content in package.`);
+                }
+                context.runtime.packageTransports.lang.binaries = aLangTransports[0];
+                logger_1.Logger.log(`LANG transport is ${context.runtime.packageTransports.lang.binaries.trkorr}.`, true);
+                const langE071 = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.lang.binaries.binaries.data, 'E071'));
+                logger_1.Logger.log(`LANG E071: ${JSON.stringify(langE071)}`, true);
+                context.runtime.packageTransportsData.e071 = context.runtime.packageTransportsData.e071.concat(langE071);
             }
-            context.runtime.langTransport = aLangTransports[0];
-            logger_1.Logger.log(`LANG transport is ${aLangTransports[0].trkorr}.`, true);
         }
         if (aCustTransports.length > 0) {
-            if (aCustTransports.length !== 1) {
-                throw new Error(`Unexpected declaration of customizing in package ${packageName}.`);
+            if (context.rawInput.installData.import.noCust === undefined) {
+                if (!context.rawInput.contextData.noInquirer) {
+                    context.rawInput.installData.import.noCust = !(yield inquirer_1.Inquirer.prompt({
+                        type: `confirm`,
+                        name: `noCust`,
+                        message: `Import customizing transport?`,
+                        default: true,
+                    })).noCust;
+                }
             }
-            context.runtime.custTransport = aCustTransports[0];
-            logger_1.Logger.log(`CUST transport is ${aCustTransports[0].trkorr}.`, true);
+            if (!context.rawInput.installData.import.noCust) {
+                if (aCustTransports.length !== 1) {
+                    logger_1.Logger.error(`Multiple CUST transports found`, true);
+                    throw new Error(`Unexpected content in package.`);
+                }
+                context.runtime.packageTransports.cust.binaries = aCustTransports[0];
+                logger_1.Logger.log(`CUST transport is ${context.runtime.packageTransports.cust.binaries.trkorr}.`, true);
+                const custE071 = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.cust.binaries.binaries.data, 'E071'));
+                logger_1.Logger.log(`CUST E071: ${JSON.stringify(custE071)}`, true);
+                context.runtime.packageTransportsData.e071 = context.runtime.packageTransportsData.e071.concat(custE071);
+            }
+        }
+        if (context.runtime.packageTransportsData.e071.find(o => o.pgmid === 'R3TR' && o.object === 'DEVC')) {
+            throw new Error(`Package has undeclared devclass.`);
+        }
+        var devcE071 = (0, commons_1.normalize)(yield context.runtime.r3trans.getTableEntries(context.runtime.packageTransports.devc.binaries.binaries.data, 'E071'));
+        logger_1.Logger.log(`DEVC E071: ${JSON.stringify(devcE071)}`, true);
+        devcE071 = devcE071.filter(o => o.pgmid === 'R3TR' && o.object === 'DEVC');
+        if (devcE071.length === 0) {
+            throw new Error(`Package has no devclass.`);
         }
+        context.runtime.packageTransportsData.e071 = context.runtime.packageTransportsData.e071.concat(devcE071);
+        context.runtime.installData.entries = context.runtime.packageTransportsData.e071;
     })
 };

package/dist/actions/install/generateDevclass.js

@@ -11,68 +11,71 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDevclass = void 0;
 const logger_1 = require("../../logger");
-const systemConnector_1 = require("../../systemConnector");
 const commons_1 = require("../../commons");
+const systemConnector_1 = require("../../systemConnector");
 exports.generateDevclass = {
     name: 'generate-devclass',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const packageReplacements = context.runtime.packageReplacements;
-        if (packageReplacements && packageReplacements.length > 0) {
-            return true;
+        if (context.rawInput.installData.installDevclass.keepOriginal) {
+            logger_1.Logger.log(`Skipping generate devclass devclass (user input)`, true);
+            return false;
         }
         else {
-            logger_1.Logger.log(`Skip generate devclass (no package replacements)`, true);
-            return false;
+            return true;
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
         var _a, _b;
-        var pdevclass = context.parsedInput.transportLayer;
-        const packageReplacements = context.runtime.packageReplacements;
-        const packageName = context.parsedInput.packageName;
-        const tdevct = context.runtime.tdevctData;
-        const dlvunit = (0, commons_1.getPackageNamespace)(packageReplacements[0].installDevclass) === '$' ? 'LOCAL' : 'HOME';
-        context.runtime.generatedDevclass = [];
-        logger_1.Logger.loading(`Generating packages...`);
-        for (const packageReplacement of packageReplacements) {
-            const devclassExists = yield systemConnector_1.SystemConnector.getDevclass(packageReplacement.installDevclass);
-            const oDevcTadir = {
-                pgmid: 'R3TR',
-                object: 'DEVC',
-                objName: packageReplacement.installDevclass,
-                devclass: packageReplacement.installDevclass
-            };
-            if (!devclassExists) {
-                logger_1.Logger.loading(`Generating "${packageReplacement.installDevclass}"...`);
-                if (!pdevclass) {
-                    pdevclass = yield systemConnector_1.SystemConnector.getDefaultTransportLayer();
-                }
-                const ctext = ((_a = tdevct.find(o => o.devclass === packageReplacement.originalDevclass)) === null || _a === void 0 ? void 0 : _a.ctext) || `TRM ${packageName}`;
+        logger_1.Logger.log('Generate devclass step', true);
+        logger_1.Logger.loading(`Checking ABAP packages...`);
+        var generate = [];
+        for (const replacement of context.rawInput.installData.installDevclass.replacements) {
+            logger_1.Logger.loading(`Checking existance of devclass ${replacement.installDevclass}...`, true);
+            const oDevclass = yield systemConnector_1.SystemConnector.getDevclass(replacement.installDevclass);
+            if (oDevclass) {
+                logger_1.Logger.log(`Devclass ${replacement.installDevclass} exists, skipping generation`, true);
+            }
+            else {
+                logger_1.Logger.log(`Devclass ${replacement.installDevclass} doesn't exist, will be generated`, true);
+                generate.push(replacement.installDevclass);
+            }
+        }
+        if (generate.length > 0) {
+            const dlvunit = context.runtime.installData.namespace === '$' ? 'LOCAL' : 'HOME';
+            for (const devclass of generate) {
+                logger_1.Logger.loading(`Creating package ${devclass}...`);
+                const originalDevclass = context.rawInput.installData.installDevclass.replacements.find(o => o.installDevclass === devclass).originalDevclass;
+                logger_1.Logger.log(`Original devclass ${originalDevclass}`, true);
+                const ctext = ((_a = context.runtime.packageTransportsData.tdevct.find(o => o.devclass === originalDevclass)) === null || _a === void 0 ? void 0 : _a.ctext) || `TRM ${context.rawInput.packageData.name}`;
                 yield systemConnector_1.SystemConnector.createPackage({
-                    devclass: packageReplacement.installDevclass,
                     as4user: systemConnector_1.SystemConnector.getLogonUser(),
+                    pdevclass: context.rawInput.installData.installDevclass.transportLayer,
+                    devclass,
                     ctext,
-                    dlvunit,
-                    pdevclass
+                    dlvunit
                 });
-                context.runtime.generatedDevclass.push(packageReplacement.installDevclass);
-            }
-            if (dlvunit !== 'LOCAL') {
-                yield systemConnector_1.SystemConnector.tadirInterface(oDevcTadir);
-                context.runtime.tadirData.push(oDevcTadir);
+                context.runtime.generatedData.devclass.push(devclass);
+                if (dlvunit !== 'LOCAL') {
+                    yield systemConnector_1.SystemConnector.tadirInterface({
+                        pgmid: 'R3TR',
+                        object: 'DEVC',
+                        objName: devclass,
+                        devclass,
+                        srcsystem: 'TRM'
+                    });
+                }
             }
         }
-        logger_1.Logger.loading(`Finalizing packages...`);
+        logger_1.Logger.loading(`Updating ABAP packages hierarchy...`);
         const aDummyTdevc = [];
-        const originalPackageHierarchy = context.runtime.originalPackageHierarchy;
-        const tdevc = context.runtime.tdevcData;
-        for (const packageReplacement of packageReplacements) {
+        const originalPackageHierarchy = (0, commons_1.getPackageHierarchy)(context.runtime.packageTransportsData.tdevc);
+        for (const packageReplacement of context.rawInput.installData.installDevclass.replacements) {
             const originalRoot = originalPackageHierarchy.devclass === packageReplacement.originalDevclass;
             var parentcl;
             if (!originalRoot) {
-                const originalParentCl = tdevc.find(o => o.devclass === packageReplacement.originalDevclass).parentcl;
+                const originalParentCl = context.runtime.packageTransportsData.tdevc.find(o => o.devclass === packageReplacement.originalDevclass).parentcl;
                 if (originalParentCl) {
-                    parentcl = packageReplacements.find(o => o.originalDevclass === originalParentCl).installDevclass;
+                    parentcl = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === originalParentCl).installDevclass;
                 }
             }
             aDummyTdevc.push({
@@ -81,17 +84,17 @@ exports.generateDevclass = {
             });
         }
         const installPackageHierarchy = (0, commons_1.getPackageHierarchy)(aDummyTdevc);
-        for (const packageReplacement of packageReplacements) {
+        for (const packageReplacement of context.rawInput.installData.installDevclass.replacements) {
             const installRoot = installPackageHierarchy.devclass === packageReplacement.installDevclass;
             if (!installRoot) {
                 yield systemConnector_1.SystemConnector.clearPackageSuperpackage(packageReplacement.installDevclass);
             }
         }
-        for (const packageReplacement of packageReplacements) {
+        for (const packageReplacement of context.rawInput.installData.installDevclass.replacements) {
             const installRoot = installPackageHierarchy.devclass === packageReplacement.installDevclass;
-            const originalParentCl = tdevc.find(o => o.devclass === packageReplacement.originalDevclass).parentcl;
+            const originalParentCl = context.runtime.packageTransportsData.tdevc.find(o => o.devclass === packageReplacement.originalDevclass).parentcl;
             if (originalParentCl) {
-                const installParentCl = (_b = packageReplacements.find(o => o.originalDevclass === originalParentCl)) === null || _b === void 0 ? void 0 : _b.installDevclass;
+                const installParentCl = (_b = context.rawInput.installData.installDevclass.replacements.find(o => o.originalDevclass === originalParentCl)) === null || _b === void 0 ? void 0 : _b.installDevclass;
                 if (installParentCl) {
                     if (!installRoot) {
                         yield systemConnector_1.SystemConnector.setPackageSuperpackage(packageReplacement.installDevclass, installParentCl);
@@ -99,19 +102,5 @@ exports.generateDevclass = {
                 }
             }
         }
-        logger_1.Logger.success(`Packages generated.`);
-    }),
-    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const devclassDelete = context.runtime.generatedDevclass;
-        for (const devclass of devclassDelete) {
-            logger_1.Logger.loading(`Rollback "${devclass}"...`);
-            try {
-                logger_1.Logger.info(`Rollback "${devclass}"`);
-            }
-            catch (e) {
-                logger_1.Logger.info(`Unable to rollback "${devclass}"`);
-                logger_1.Logger.error(e.toString(), true);
-            }
-        }
     })
 };

package/dist/actions/install/{checkTadirObjectTypes.d.ts → generateInstallTransport.d.ts}

@@ -1,3 +1,3 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
-export declare const checkTadirObjectTypes: Step<InstallWorkflowContext>;
+export declare const generateInstallTransport: Step<InstallWorkflowContext>;

package/dist/actions/install/generateInstallTransport.js

@@ -0,0 +1,129 @@
+"use strict";
+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.generateInstallTransport = void 0;
+const logger_1 = require("../../logger");
+const commons_1 = require("../../commons");
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+exports.generateInstallTransport = {
+    name: 'generate-install-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.installData.installTransport.create) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skipping install transport generation (user input)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Generate install transport step', true);
+        try {
+            if ((0, commons_1.getPackageNamespace)(context.runtime.installData.namespace) === '$') {
+                logger_1.Logger.warning(`Install transport was not generated because the package contains non-transportable objects.`);
+                return;
+            }
+            logger_1.Logger.loading(`Generating install transport...`);
+            context.runtime.installData.transport = yield systemConnector_1.SystemConnector.getPackageWorkbenchTransport(context.runtime.remotePackageData.trmPackage);
+            if (context.runtime.installData.transport) {
+                logger_1.Logger.log(`Install transport (${context.runtime.installData.transport.trkorr}) already exists, won't create a new one.`, true);
+            }
+            else {
+                context.runtime.installData.transport = yield transport_1.Transport.createWb({
+                    text: `TRM generated transport`,
+                    target: context.rawInput.installData.installTransport.targetSystem || ''
+                });
+                logger_1.Logger.log(`Generated transport ${context.runtime.installData.transport.trkorr}`, true);
+            }
+            yield context.runtime.installData.transport.addComment(`name=${context.runtime.remotePackageData.trmManifest.name}`);
+            yield context.runtime.installData.transport.addComment(`version=${context.runtime.remotePackageData.trmManifest.version}`);
+            yield context.runtime.installData.transport.setDocumentation(context.runtime.remotePackageData.manifest.getAbapXml());
+            yield context.runtime.installData.transport.rename(`@X1@TRM: ${context.runtime.remotePackageData.trmManifest.name} v${context.runtime.remotePackageData.trmManifest.version}`);
+            var tadirObjects = context.runtime.packageTransportsData.tadir;
+            if (context.rawInput.installData.installDevclass.keepOriginal) {
+                tadirObjects = tadirObjects.concat(context.runtime.packageTransportsData.tdevc.map(o => {
+                    return {
+                        pgmid: 'R3TR',
+                        object: 'DEVC',
+                        objName: o.devclass,
+                        devclass: o.devclass
+                    };
+                }));
+            }
+            else {
+                tadirObjects = tadirObjects.concat(context.runtime.generatedData.devclass.map(devclass => {
+                    return {
+                        pgmid: 'R3TR',
+                        object: 'DEVC',
+                        objName: devclass,
+                        devclass: devclass
+                    };
+                }));
+            }
+            for (const tadir of tadirObjects) {
+                try {
+                    try {
+                        logger_1.Logger.log(`Adding object ${tadir.pgmid} ${tadir.object} ${tadir.objName} with lock`, true);
+                        yield context.runtime.installData.transport.addObjects([tadir], true);
+                    }
+                    catch (e) {
+                        logger_1.Logger.log(`Failed, adding object ${tadir.pgmid} ${tadir.object} ${tadir.objName} without lock`, true);
+                        yield context.runtime.installData.transport.addObjects([tadir], false);
+                    }
+                }
+                catch (e) {
+                    logger_1.Logger.error(`Failed adding object ${tadir.pgmid} ${tadir.object} ${tadir.objName}`, true);
+                    logger_1.Logger.error(e.toString(), true);
+                }
+            }
+            if (context.runtime.packageTransports.lang.instance) {
+                try {
+                    logger_1.Logger.log(`Including language transport ${context.runtime.packageTransports.lang.instance.trkorr}`, true);
+                    yield context.runtime.installData.transport.addObjectsFromTransport(context.runtime.packageTransports.lang.instance.trkorr);
+                }
+                catch (e) {
+                    logger_1.Logger.error(`Failed including language transport ${context.runtime.packageTransports.lang.instance.trkorr}`, true);
+                    logger_1.Logger.error(e.toString(), true);
+                }
+            }
+            if (context.runtime.packageTransports.cust.instance) {
+                try {
+                    logger_1.Logger.log(`Including customizing transport ${context.runtime.packageTransports.cust.instance.trkorr}`, true);
+                    yield context.runtime.installData.transport.addObjectsFromTransport(context.runtime.packageTransports.cust.instance.trkorr);
+                }
+                catch (e) {
+                    logger_1.Logger.error(`Failed including customizing transport ${context.runtime.packageTransports.cust.instance.trkorr}`, true);
+                    logger_1.Logger.error(e.toString(), true);
+                }
+            }
+            if (context.runtime.installData.namespace[0] === '/') {
+                logger_1.Logger.log(`Adding namespace ${context.runtime.installData.namespace} without lock`, true);
+                try {
+                    yield context.runtime.installData.transport.addObjects([{
+                            pgmid: 'R3TR',
+                            object: 'NSPC',
+                            objName: context.runtime.installData.namespace
+                        }], false);
+                }
+                catch (e) {
+                    logger_1.Logger.error(`Failed adding namespace ${context.runtime.installData.namespace}`, true);
+                    logger_1.Logger.error(e.toString(), true);
+                }
+            }
+            logger_1.Logger.success(`Use ${context.runtime.installData.transport.trkorr} for transports in your landscape.`);
+        }
+        catch (e) {
+            logger_1.Logger.error(`An error occurred during install transport generation.`);
+            logger_1.Logger.error(e.toString(), true);
+        }
+    })
+};

package/dist/actions/install/importCustTransport.js

@@ -16,33 +16,29 @@ const transport_1 = require("../../transport");
 exports.importCustTransport = {
     name: 'import-cust-transport',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.runtime.custTransport) {
-            if (context.parsedInput.skipCustImport) {
-                logger_1.Logger.log(`Skip import CUST transport (input)`, true);
-                return false;
-            }
-            else {
-                return true;
-            }
+        if (context.rawInput.installData.import.noCust) {
+            logger_1.Logger.log(`Skipping import CUST transport (user input)`, true);
+            return false;
         }
         else {
-            logger_1.Logger.log(`Skip import CUST transport (no transport data in package)`, true);
             return false;
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const importTimeout = context.parsedInput.importTimeout;
-        const transportData = context.runtime.custTransport;
-        const target = systemConnector_1.SystemConnector.getDest();
-        logger_1.Logger.loading(`Importing transport to ${target}...`);
-        const transport = yield transport_1.Transport.upload({
-            binary: transportData.binaries,
-            trTarget: target
+        logger_1.Logger.log('Import CUST Transport step', true);
+        logger_1.Logger.loading(`Importing...`);
+        const importTimeout = context.rawInput.installData.import.timeout;
+        logger_1.Logger.loading(`Uploading ${context.runtime.packageTransports.cust.binaries.trkorr}`, true);
+        context.runtime.packageTransports.cust.instance = yield transport_1.Transport.upload({
+            binary: context.runtime.packageTransports.cust.binaries.binaries,
+            trTarget: systemConnector_1.SystemConnector.getDest()
         });
-        yield transport.import(importTimeout);
-        context.runtime.trCopy.push(transportData.trkorr);
+        logger_1.Logger.loading(`Importing ${context.runtime.packageTransports.cust.binaries.trkorr}`, true);
+        yield context.runtime.packageTransports.cust.instance.import(importTimeout);
+        logger_1.Logger.success(`Transport ${context.runtime.packageTransports.cust.binaries.trkorr} imported`, true);
     }),
     revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        logger_1.Logger.error(`CUST transport ${context.runtime.langTransport} can't be removed.`);
+        logger_1.Logger.log('Rollback CUST Transport step', true);
+        logger_1.Logger.warning(`Customizing transport ${context.runtime.packageTransports.cust.binaries.trkorr} can't be reverted.`);
     })
 };

package/dist/actions/install/{generateWbTransport.d.ts → importDevcTransport.d.ts}

@@ -1,3 +1,3 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
-export declare const generateWbTransport: Step<InstallWorkflowContext>;
+export declare const importDevcTransport: Step<InstallWorkflowContext>;

package/dist/actions/install/importDevcTransport.js

@@ -0,0 +1,61 @@
+"use strict";
+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.importDevcTransport = void 0;
+const logger_1 = require("../../logger");
+const systemConnector_1 = require("../../systemConnector");
+const transport_1 = require("../../transport");
+exports.importDevcTransport = {
+    name: 'import-devc-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.installData.installDevclass.keepOriginal) {
+            return true;
+        }
+        else {
+            logger_1.Logger.log(`Skipping import DEVC transport (user input - devclass already generated)`, true);
+            return false;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Import DEVC Transport step', true);
+        logger_1.Logger.loading(`Getting ready to import...`);
+        const rootDevclass = yield systemConnector_1.SystemConnector.getDevclass(context.runtime.originalData.hierarchy.devclass);
+        logger_1.Logger.loading(`Importing...`);
+        const importTimeout = context.rawInput.installData.import.timeout;
+        logger_1.Logger.loading(`Uploading ${context.runtime.packageTransports.devc.binaries.trkorr}`, true);
+        context.runtime.packageTransports.devc.instance = yield transport_1.Transport.upload({
+            binary: context.runtime.packageTransports.devc.binaries.binaries,
+            trTarget: systemConnector_1.SystemConnector.getDest()
+        });
+        logger_1.Logger.loading(`Importing ${context.runtime.packageTransports.devc.binaries.trkorr}`, true);
+        yield context.runtime.packageTransports.devc.instance.import(importTimeout);
+        logger_1.Logger.success(`Transport ${context.runtime.packageTransports.devc.binaries.trkorr} imported`, true);
+        logger_1.Logger.loading(`Finalizing import...`);
+        if (rootDevclass && rootDevclass.parentcl) {
+            yield systemConnector_1.SystemConnector.setPackageSuperpackage(context.runtime.originalData.hierarchy.devclass, rootDevclass.parentcl);
+        }
+        for (const tdevc of context.runtime.packageTransportsData.tdevc) {
+            const object = {
+                pgmid: 'R3TR',
+                object: 'DEVC',
+                objName: tdevc.devclass,
+                devclass: tdevc.devclass,
+                srcsystem: 'TRM'
+            };
+            logger_1.Logger.log(`Running TADIR interface for object ${object.pgmid} ${object.object} ${object.objName}, devclass ${object.devclass} -> src system ${object.srcsystem}`, true);
+            yield systemConnector_1.SystemConnector.tadirInterface(object);
+        }
+        for (const tdevc of context.runtime.packageTransportsData.tdevc) {
+            logger_1.Logger.log(`Running TDEVC interface for devclass ${tdevc.devclass} -> transport layer ${context.rawInput.installData.installDevclass.transportLayer}`, true);
+            yield systemConnector_1.SystemConnector.setPackageTransportLayer(tdevc.devclass, context.rawInput.installData.installDevclass.transportLayer);
+        }
+    })
+};

package/dist/actions/install/importLangTransport.js

@@ -16,33 +16,29 @@ const transport_1 = require("../../transport");
 exports.importLangTransport = {
     name: 'import-lang-transport',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.runtime.langTransport) {
-            if (context.parsedInput.skipLangImport) {
-                logger_1.Logger.log(`Skip import LANG transport (input)`, true);
-                return false;
-            }
-            else {
-                return true;
-            }
+        if (context.rawInput.installData.import.noLang) {
+            logger_1.Logger.log(`Skipping import LANG transport (user input)`, true);
+            return false;
         }
         else {
-            logger_1.Logger.log(`Skip import LANG transport (no transport data in package)`, true);
             return false;
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const importTimeout = context.parsedInput.importTimeout;
-        const transportData = context.runtime.langTransport;
-        const target = systemConnector_1.SystemConnector.getDest();
-        logger_1.Logger.loading(`Importing transport to ${target}...`);
-        const transport = yield transport_1.Transport.upload({
-            binary: transportData.binaries,
-            trTarget: target
+        logger_1.Logger.log('Import LANG Transport step', true);
+        logger_1.Logger.loading(`Importing...`);
+        const importTimeout = context.rawInput.installData.import.timeout;
+        logger_1.Logger.loading(`Uploading ${context.runtime.packageTransports.lang.binaries.trkorr}`, true);
+        context.runtime.packageTransports.lang.instance = yield transport_1.Transport.upload({
+            binary: context.runtime.packageTransports.lang.binaries.binaries,
+            trTarget: systemConnector_1.SystemConnector.getDest()
         });
-        yield transport.import(importTimeout);
-        context.runtime.trCopy.push(transportData.trkorr);
+        logger_1.Logger.loading(`Importing ${context.runtime.packageTransports.lang.binaries.trkorr}`, true);
+        yield context.runtime.packageTransports.lang.instance.import(importTimeout);
+        logger_1.Logger.success(`Transport ${context.runtime.packageTransports.lang.binaries.trkorr} imported`, true);
     }),
     revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        logger_1.Logger.error(`LANG transport ${context.runtime.langTransport} can't be removed.`);
+        logger_1.Logger.log('Rollback LANG Transport step', true);
+        logger_1.Logger.warning(`Language transport ${context.runtime.packageTransports.lang.binaries.trkorr} can't be reverted.`);
     })
 };