trm-client
Version:
TRM (Transport Request Manager) Client
337 lines (336 loc) • 14.2 kB
JavaScript
;
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.connect = connect;
const systemAlias_1 = require("../../systemAlias");
const utils_1 = require("../../utils");
const normalize_url_1 = __importDefault(require("@esm2cjs/normalize-url"));
const trm_commons_1 = require("trm-commons");
const languageList = [
{ value: 'AR', name: 'AR (Arabic)' },
{ value: 'BG', name: 'BG (Bulgarian)' },
{ value: 'CA', name: 'CA (Catalan)' },
{ value: 'ZH', name: 'ZH (Chinese, simplified)' },
{ value: 'ZT', name: 'ZT (Chinese, traditional)' },
{ value: 'HR', name: 'HR (Croatian)' },
{ value: 'CS', name: 'CS (Czech)' },
{ value: 'DA', name: 'DA (Danish)' },
{ value: 'NL', name: 'NL (Dutch)' },
{ value: 'EN', name: 'EN (English)' },
{ value: 'ET', name: 'ET (Estonian)' },
{ value: 'FI', name: 'FI (Finnish)' },
{ value: 'FR', name: 'FR (French)' },
{ value: 'DE', name: 'DE (German)' },
{ value: 'EL', name: 'EL (Greek)' },
{ value: 'HE', name: 'HE (Hebrew)' },
{ value: 'HI', name: 'HI (Hindi)' },
{ value: 'HU', name: 'HU (Hungarian)' },
{ value: 'IT', name: 'IT (Italian)' },
{ value: 'JA', name: 'JA (Japanese)' },
{ value: 'KK', name: 'KK (Kazakh)' },
{ value: 'KO', name: 'KO (Korean)' },
{ value: 'LV', name: 'LV (Latvian)' },
{ value: 'LT', name: 'LT (Lithuanian)' },
{ value: 'MS', name: 'MS (Malay)' },
{ value: 'NO', name: 'NO (Norwegian)' },
{ value: 'PL', name: 'PL (Polish)' },
{ value: 'PT', name: 'PT (Portuguese)' },
{ value: 'RO', name: 'RO (Romanian)' },
{ value: 'RU', name: 'RU (Russian)' },
{ value: 'SH', name: 'SH (Serbian, Latin)' },
{ value: 'SK', name: 'SK (Slovak)' },
{ value: 'SL', name: 'SL (Slovenian)' },
{ value: 'ES', name: 'ES (Spanish)' },
{ value: 'SV', name: 'SV (Swedish)' },
{ value: 'TH', name: 'TH (Thai)' },
{ value: 'TR', name: 'TR (Turkish)' },
{ value: 'UK', name: 'UK (Ukrainian)' },
{ value: 'VI', name: 'VI (Vietnamese)' }
];
const _createAliasIfNotExists = () => {
};
function connect(commandArgs_1) {
return __awaiter(this, arguments, void 0, function* (commandArgs, createAliasIfNotExist = true, addNoConnection) {
const noSystemAlias = commandArgs.noSystemAlias ? true : false;
const force = commandArgs.force ? true : false;
var type = commandArgs.type;
var aInputType = [];
var aSapLogonConnections;
const aAlias = systemAlias_1.SystemAlias.getAll();
try {
aSapLogonConnections = yield (0, utils_1.getSapLogonConnections)();
}
catch (e) {
aSapLogonConnections = [];
}
if (addNoConnection) {
aInputType.push({
value: 'none', name: 'No connection'
});
}
if (aAlias.length > 0 && !noSystemAlias) {
aInputType.push({
value: 'alias', name: 'System Alias'
});
}
aInputType.push({
value: 'input', name: 'Manual input'
});
if (aSapLogonConnections.length > 0) {
aInputType.push({
value: 'logon', name: 'SAP Logon Connection (Uses node-rfc)'
});
}
var result;
var inputType;
if (!commandArgs.ashost && !commandArgs.dest && !commandArgs.sysnr) {
const inq1 = yield trm_commons_1.Inquirer.prompt({
type: `list`,
name: `inputType`,
message: `Select connection type`,
choices: aInputType
});
inputType = inq1.inputType;
}
else {
inputType = 'input';
}
if (inputType === 'none') {
return {
connection: new utils_1.NoConnection()
};
}
else if (inputType === 'alias') {
const inq2 = yield trm_commons_1.Inquirer.prompt({
type: `list`,
name: `aliasName`,
message: `Select alias`,
choices: aAlias.map(o => {
return {
value: o.alias, name: o.alias
};
})
});
const alias = aAlias.find(o => o.alias === inq2.aliasName);
result = Object.assign(Object.assign({}, alias.connection), alias.login);
type = alias.type;
createAliasIfNotExist = false;
}
else {
if (inputType === 'logon') {
const inq3 = yield trm_commons_1.Inquirer.prompt({
type: `list`,
name: `logonConnection`,
message: `Select connection`,
choices: aSapLogonConnections.map(o => {
return {
value: o.id, name: o.name
};
})
});
const logonConnection = aSapLogonConnections.find(o => o.id === inq3.logonConnection);
commandArgs.ashost = logonConnection.ashost;
commandArgs.dest = logonConnection.dest;
commandArgs.sysnr = logonConnection.sysnr;
commandArgs.saprouter = logonConnection.saprouter;
type = utils_1.SystemConnectorType.RFC;
}
else {
type = commandArgs.type;
}
result = yield trm_commons_1.Inquirer.prompt([{
type: `list`,
name: `type`,
message: `Connection type`,
choices: [{
value: 'REST',
name: 'REST (Requires trm-rest)'
}, {
value: 'RFC',
name: 'RFC (Uses node-rfc)'
}],
when: (type ? false : true) || force
},
{
type: `input`,
name: `endpoint`,
message: `System endpoint`,
default: commandArgs.endpoint,
when: (hash) => {
return hash.type === 'REST' && ((commandArgs.endpoint ? false : true) || force);
}
}, {
type: `input`,
name: `forwardRfcDest`,
message: `Forward RFC Destination`,
default: commandArgs.forwardRfcDest || 'NONE',
when: (hash) => {
return hash.type === 'REST' && (commandArgs.forwardRfcDest || force);
}
},
{
type: `input`,
name: `ashost`,
message: `Application server`,
default: commandArgs.ashost,
when: (hash) => {
return hash.type === 'RFC' && ((commandArgs.ashost ? false : true) || force);
}
}, {
type: `input`,
name: `dest`,
message: `System ID`,
default: commandArgs.dest,
when: (hash) => {
return hash.type === 'RFC' && ((commandArgs.dest ? false : true) || force);
},
validate: (val) => {
if (val && /^\w{3}$/.test(val)) {
return true;
}
else {
return `Invalid input: expected length 3, only letters allowed`;
}
}
}, {
type: `input`,
name: `sysnr`,
message: `Instance number`,
default: commandArgs.sysnr,
when: (hash) => {
return hash.type === 'RFC' && ((commandArgs.sysnr ? false : true) || force);
},
validate: (val) => {
if (val && /^\d{2}$/.test(val)) {
return true;
}
else {
return `Invalid input: expected length 2, only numbers allowed`;
}
}
}, {
type: `input`,
name: `saprouter`,
message: `SAProuter`,
default: commandArgs.saprouter,
when: (hash) => {
return hash.type === 'RFC' && ((commandArgs.saprouter ? false : true) || force);
}
}, {
type: `input`,
name: `client`,
message: `Logon Client`,
default: commandArgs.client,
when: (hash) => {
return (commandArgs.client ? false : true) || force;
},
validate: (val) => {
if (val && /^\d{3}$/.test(val)) {
return true;
}
else {
return `Invalid input: expected length 3, only numbers allowed`;
}
}
}, {
type: `input`,
name: `user`,
message: `Logon User`,
default: commandArgs.user,
when: (hash) => {
return (commandArgs.user ? false : true) || force;
}
}, {
type: `password`,
name: `passwd`,
message: `Logon Password`,
default: commandArgs.passwd,
when: (hash) => {
return (commandArgs.passwd ? false : true) || force;
}
}, {
type: `list`,
name: `lang`,
message: `Logon Language`,
default: commandArgs.lang || 'EN',
when: (hash) => {
return (commandArgs.lang ? false : true) || force;
},
validate: (input) => {
return languageList.includes(input.trim().toUpperCase());
},
choices: languageList
}]);
}
result.type = result.type || type;
result.user = result.user || commandArgs.user;
result.passwd = result.passwd || commandArgs.passwd;
result.lang = result.lang || commandArgs.lang;
result.user = result.user.toUpperCase();
result.lang = result.lang.toUpperCase();
if (result.type === utils_1.SystemConnectorType.RFC) {
result.ashost = result.ashost || commandArgs.ashost;
result.dest = result.dest || commandArgs.dest;
result.saprouter = result.saprouter || commandArgs.saprouter;
result.sysnr = result.sysnr || commandArgs.sysnr;
result.client = result.client || commandArgs.client;
result.noSystemAlias = commandArgs.noSystemAlias;
result.dest = result.dest.toUpperCase();
result.connection = (0, utils_1.getSystemConnector)(utils_1.SystemConnectorType.RFC, {
connection: {
dest: result.dest,
ashost: result.ashost,
sysnr: result.sysnr,
saprouter: result.saprouter
},
login: {
user: result.user,
passwd: result.passwd,
lang: result.lang,
client: result.client
}
});
}
else if (result.type === utils_1.SystemConnectorType.REST) {
result.endpoint = result.endpoint || commandArgs.endpoint;
result.forwardRfcDest = result.forwardRfcDest || commandArgs.forwardRfcDest;
result.client = result.client || commandArgs.client;
if (result.forwardRfcDest) {
result.forwardRfcDest = result.forwardRfcDest.toUpperCase();
}
result.endpoint = (0, normalize_url_1.default)(result.endpoint, {
removeTrailingSlash: true
});
result.connection = (0, utils_1.getSystemConnector)(utils_1.SystemConnectorType.REST, {
connection: {
endpoint: result.endpoint,
rfcdest: result.forwardRfcDest || 'NONE'
},
login: {
user: result.user,
passwd: result.passwd,
lang: result.lang,
client: result.client
}
});
}
else {
throw new Error(`Unknown connection type "${result.type}".`);
}
if (createAliasIfNotExist) {
yield systemAlias_1.SystemAlias.createIfNotExists(result);
}
return result;
});
}