@zohocorporation/vault-cli 1.1.2

package/out/old/Default.js

@@ -0,0 +1,209 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import Vault from "../js/crypto/index.js";
+import Table from "cli-table3";
+import { I18N } from "../js/I18n/index.js";
+import { getDecryptedCredentials, updateTable } from "../util/dbutils/db.utils.js";
+import { generateWorkspaceHash } from "../commands/login/login.utils.js";
+import { encryptString } from "../util/encryptionutil/encryption.uitl.js";
+let i18nText = new I18N();
+export class Default {
+    constructor(optionCommand, command, update) {
+        if (!(optionCommand === undefined)) {
+            this.options = optionCommand;
+            command = (command === undefined) ? [] : command.split(',');
+            let unknownCommand = [];
+            let knownCommand = [];
+            this.commandNames = Object.keys(this.options);
+            this.commandNames = this.commandNames.map(name => name.toLowerCase());
+            command = command.map(name => name.toLowerCase());
+            for (let c in command) {
+                if (Object.keys(this.options).includes(command[c])) {
+                    knownCommand.push(command[c]);
+                }
+                else {
+                    unknownCommand.push(command[c]);
+                }
+            }
+            this.command = knownCommand;
+            if (command.length > 0 && command !== undefined) {
+                if (knownCommand.length === 0) {
+                    console.log(chalk.red(i18nText.getI18nMsg("vault.defaults.noCommands")));
+                    console.log(chalk.green(i18nText.getI18nMsg("vault.defaults.commandsSuggestion") + Object.keys(this.options).join()));
+                    this.command = undefined;
+                }
+                else if (unknownCommand.length > 0) {
+                    console.log(chalk.red(i18nText.getI18nMsg("vault.defaults.invalidCommand") + unknownCommand.join()));
+                    console.log(chalk.green(i18nText.getI18nMsg("vault.defaults.commandConsidered") + knownCommand.join()));
+                    this.command = knownCommand;
+                }
+            }
+            else {
+                this.command = undefined;
+            }
+        }
+        else if (command !== undefined) {
+            this.command = command.split(',');
+        }
+        this.update = update;
+    }
+    async setDefaults() {
+        const noValueOptions = {
+            "unlock": ["no-trust"],
+            "search": ["strict", "tags", "desc", "name", "verbose", "not-safe"], //No I18N
+            "generate-password": ["use-password-policy", "include-upper-case", "include-lower-case", "include-numbers"],
+            "get": ["not-safe"],
+            "list": ["not-safe", "verbose"]
+        };
+        const noValueCommands = Object.keys(noValueOptions);
+        if (this.command === undefined) {
+            let setCommand = await inquirer.prompt([{
+                    name: 'answer', //No I18N
+                    type: 'checkbox', //No I18N
+                    message: i18nText.getI18nMsg("vault.defaults.select_command"),
+                    choices: Object.keys(this.options)
+                }]);
+            this.command = setCommand.answer;
+        }
+        let commandOptions = {};
+        for (let c in this.command) {
+            var displayTable = new Table({
+                chars: {
+                    'top': '═', 'top-mid': '╤', 'top-left': '╔', 'top-right': '╗',
+                    'bottom': '═', 'bottom-mid': '╧', 'bottom-left': '╚', 'bottom-right': '╝',
+                    'left': '║', 'left-mid': '╟', 'mid': '─', 'mid-mid': '┼',
+                    'right': '║', 'right-mid': '╢', 'middle': '│'
+                },
+                wordWrap: true,
+                wrapWords: true,
+            });
+            if (noValueCommands.includes(this.command[c])) {
+                displayTable.push(["Command : " + chalk.blue.bold(this.command[c]) + "\nNote: " +
+                        noValueOptions[this.command[c]].join(",") + " does not require any input"]);
+                console.log(displayTable.toString());
+            }
+            else {
+                console.log("Command :" + chalk.blue.bold(this.command[c]) + "\n");
+            }
+            let setOptions = await inquirer.prompt([{
+                    name: 'answer', //No I18N
+                    type: 'checkbox', //No I18N
+                    message: i18nText.getI18nMsg("vault.defaults.select_option"),
+                    choices: this.getFlagsfromOptions(this.command[c])
+                }]);
+            setOptions = setOptions.answer;
+            let OptionsQuestion = [];
+            for (let i in setOptions) {
+                OptionsQuestion.push({
+                    name: setOptions[i].flag,
+                    type: 'input', //No I18N
+                    message: i18nText.getI18nMsg("vault.defaults.promptAnswer") + setOptions[i].name + ' -' //No I18N
+                });
+            }
+            let answer = await inquirer.prompt(OptionsQuestion);
+            Object.keys(answer).forEach((key) => {
+                if (typeof answer[key] === 'string') {
+                    answer[key] = answer[key].trim();
+                }
+            });
+            if (Object.keys(answer).length !== 0) {
+                commandOptions[this.command[c]] = answer;
+            }
+        }
+        let credentialData = await getDecryptedCredentials(generateWorkspaceHash());
+        if (this.update) {
+            this.command = undefined;
+            await this.getDefaults();
+            commandOptions = this._mergedefaults(commandOptions, this.defaults);
+        }
+        this.sanitizeCommandOptions(commandOptions, noValueOptions);
+        credentialData.defaults = await encryptString(Vault.Base64_encode(JSON.stringify(commandOptions)));
+        updateTable(generateWorkspaceHash(), credentialData.defaults);
+    }
+    sanitizeCommandOptions(commandOptions, noValueCommands) {
+        for (let cmd in commandOptions) {
+            const commandOpts = commandOptions[cmd];
+            const options = noValueCommands[cmd];
+            for (let opt in commandOpts) {
+                if (options && options.includes(opt.slice(2))) {
+                    commandOpts[opt] = true;
+                }
+            }
+        }
+    }
+    async getDefaults() {
+        let defaults = {};
+        let credentialData = await getDecryptedCredentials(generateWorkspaceHash());
+        if (credentialData.defaults === undefined) {
+            defaults = {};
+        }
+        else {
+            defaults = credentialData.defaults;
+        }
+        if (this.command === undefined) {
+            this.defaults = defaults;
+        }
+        else {
+            let newDefaults = {};
+            for (let i in this.command) {
+                if (defaults[this.command[i]] !== undefined) {
+                    newDefaults[this.command[i]] = defaults[this.command[i]];
+                }
+            }
+            this.defaults = newDefaults;
+        }
+        return this.defaults;
+    }
+    formatDefaultasTable() {
+        let table = new Table({
+            head: [i18nText.getI18nMsg("vault.default.command"), i18nText.getI18nMsg("vault.default.flag"), i18nText.getI18nMsg("vault.default.value")],
+            wordWrap: true,
+            wrapWords: true,
+            style: { head: ['blue', 'bold'], border: ['grey'] } //No I18N
+        });
+        if (Object.keys(this.defaults).length === 0) {
+            table.push([{ colSpan: 3, vAlign: 'center', content: i18nText.getI18nMsg("vault.default.notConfigured") }]);
+        }
+        else {
+            for (let c in this.defaults) {
+                let flags = Object.keys(this.defaults[c]);
+                table.push([{ rowSpan: flags.length, vAlign: 'center', content: c }, flags[0], this.defaults[c][flags[0]]] //No I18N
+                );
+                if (flags.length !== 1) {
+                    for (let index = 1; index < flags.length; index++) {
+                        table.push([flags[index], this.defaults[c][flags[index]]]);
+                    }
+                }
+            }
+        }
+        console.log(table.toString());
+    }
+    getFlagsfromOptions(command) {
+        let commandOptions = this.options[command];
+        let output = [];
+        for (let opt in commandOptions) {
+            output.push({
+                name: opt,
+                value: { flag: commandOptions[opt].flag, name: opt }
+            });
+        }
+        return output;
+    }
+    _mergedefaults(json1, json2) {
+        let json1Keys = Object.keys(json1);
+        let json2Keys = Object.keys(json2);
+        for (let key in json1Keys) {
+            if (json2Keys.includes(json1Keys[key])) {
+                let Object1Keys = Object.keys(json1[json1Keys[key]]);
+                let Object2Keys = Object.keys(json2[json1Keys[key]]);
+                var diffdefaults = Object2Keys.filter((flag) => { return !(Object1Keys.includes(flag)); });
+                diffdefaults.forEach((item, index) => {
+                    json1[json1Keys[key]][item] = json2[json1Keys[key]][item];
+                });
+            }
+            json2[json1Keys[key]] = json1[json1Keys[key]];
+        }
+        return json2;
+    }
+}
+//# sourceMappingURL=Default.js.map

package/out/old/Download.js

@@ -0,0 +1,69 @@
+import { Login } from "../util/login.util.js";
+import { _pull, Utilities } from "../util/index.util.js";
+import Vault from "../js/crypto/index.js";
+import { I18N } from "../js/I18n/index.js";
+import fs from "node:fs";
+import { VAULT_ENDPOINTS } from "../util/consts.util.js";
+import { header } from "../commands/login/login.utils.js";
+import atob from "atob";
+import path from "node:path";
+import { Logger } from "../js/logger/index.js";
+let i18nText;
+export class Download extends Login {
+    constructor(passwordId, dir) {
+        super();
+        this.passwordId = passwordId;
+        if (fs.existsSync(dir)) {
+            this.dir = dir;
+        }
+        else {
+            this.dir = '';
+        }
+        i18nText = new I18N();
+    }
+    async download() {
+        try {
+            await this.getDcAndSetHeader();
+            this.masterKey = await this.getMasterKeyAfterConfiguration();
+            const resp = await _pull(header, `${Utilities.getVaultUrl(this.dc)}${VAULT_ENDPOINTS.URL_OLD_SECRETS}`, { secretId: this.passwordId, OPERATION_NAME: "GET_SECRET_FILES" }, //No I18N
+            "POST" //No I18N
+            );
+            const { result, details } = resp.data.operation;
+            if (result.status !== "success") {
+                console.log(i18nText.getI18nMsg("vault.download.noFiles"));
+                process.exit(1);
+            }
+            const files = JSON.parse(details.FILEDATA);
+            if (files.length === 0) {
+                console.log(i18nText.getI18nMsg("vault.download.noFiles"));
+            }
+            let filesDownloaded = [];
+            for (let i = 0; i < files.length; i++) {
+                var content;
+                const file = files[i];
+                var filename = file.name;
+                var cipherData = (file.data !== undefined) ? file.data : "";
+                const key = file.isShared === "YES" ? await this.getOrgKey() : this.masterKey; //No I18N
+                var filedata = Vault.fileDecrypt(cipherData, key);
+                if (filedata.split(",")[0].indexOf('base64') >= 0) {
+                    content = atob(filedata.split(",")[1]);
+                }
+                var len = content.length, arr = new Array(len);
+                for (var idx = 0; idx < len; ++idx) {
+                    arr[idx] = content.charCodeAt(idx);
+                }
+                var arrayBuffer = Buffer.from(arr);
+                const filePath = path.join(this.dir, filename);
+                Utilities.writeToFile(arrayBuffer, filePath);
+                filesDownloaded.push(filename);
+            }
+            console.log(i18nText.getI18nMsg("vault.download.success"));
+            console.log(i18nText.getI18nMsg("vault.download.filesDownloaded") + filesDownloaded.join());
+        }
+        catch (e) {
+            Logger.error(r);
+            // console.log(e)
+        }
+    }
+}
+//# sourceMappingURL=Download.js.map

package/out/old/Generate.js

@@ -0,0 +1,171 @@
+import { Login } from "../util/login.util.js";
+import { PasswordPolicies } from "./PasswordPolicies.js";
+import { Utilites } from "./index.js";
+import { PasswordGenerator } from "./PasswordGenerator.js";
+import { PasswordTypes } from "../util/passwordtypes.util.js";
+import { I18N } from "../js/I18n/index.js";
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+let i18nText;
+export class Generate extends Login {
+    constructor(policyId, templateId, type, format, outFile) {
+        super();
+        this.policyId = policyId;
+        this.templateId = templateId;
+        this.type = type;
+        this.format = format;
+        let dirPath = outFile;
+        if (outFile !== undefined) {
+            dirPath = path.parse(outFile).dir;
+            if ((outFile === undefined || outFile === '' || fs.existsSync(dirPath) || dirPath === '')) {
+                this.outFile = outFile;
+            }
+            else {
+                console.log(chalk.red('Invalid File Path provided'));
+                this.outFile = undefined;
+            }
+        }
+        else {
+            this.outFile = undefined;
+        }
+        i18nText = new I18N();
+    }
+    formatPoliciesForTable(policies) {
+        const arr = [];
+        for (let i = 0; i < policies.length; i++) {
+            arr.push({
+                SNO: i + 1,
+                "POLICY ID": policies[i].policy_id,
+                Name: policies[i].policy_name,
+                Description: policies[i].policy_description,
+            });
+        }
+        Utilites.printTable(arr);
+    }
+    formatTypesForTable(pTypes) {
+        const arr = [];
+        let i = 0;
+        for (const pTypeId in pTypes) {
+            const pType = pTypes[pTypeId];
+            arr.push({
+                SNO: ++i,
+                "Category ID": pTypeId, //NO I18N
+                "Category Name": pType.secret_type_name //NO I18N
+            });
+        }
+        Utilites.printTable(arr);
+        return arr;
+    }
+    async generatePassword() {
+        if (this.policyId === undefined) {
+            const policies = await PasswordPolicies.getPolicies(this.dc);
+            this.formatPoliciesForTable(policies);
+            this.policyId =
+                policies[(await Utilites.selectionPrompt(1, policies.length, i18nText.getI18nMsg("vault.selectionPrompt.Category"))) - 1 //NO I18N
+                ].policy_id;
+        }
+        const policy = await PasswordPolicies.getPolicies(this.dc, this.policyId);
+        const { characters_not_allowed, min_length, enforce_mixed_case, no_of_special_characters, start_with_alphabet, enforce_numerals, enforce_special_characters, max_length, } = policy;
+        PasswordGenerator.init(characters_not_allowed);
+        const password = PasswordGenerator.generatePassword(min_length, max_length, enforce_mixed_case, enforce_special_characters, no_of_special_characters, start_with_alphabet, enforce_numerals, true);
+        console.log(password);
+    }
+    async getPolicyDetails() {
+        await this.getDcAndSetHeader();
+        if (this.policyId === undefined) {
+            const policies = await PasswordPolicies.getPolicies(this.dc);
+            this.formatPoliciesForTable(policies);
+            this.policyId =
+                policies[(await Utilites.selectionPrompt(1, policies.length, i18nText.getI18nMsg("vault.selectionPrompt.policyNumber"))) - 1 //NO I18N
+                ].policy_id;
+        }
+        const policy = await PasswordPolicies.getPolicies(this.dc, this.policyId);
+        return policy;
+    }
+    async getDefaultPasswordPloicy() {
+        await this.getDcAndSetHeader();
+        let policies = await PasswordPolicies.getPolicies(this.dc);
+        for (let i = 0; i < policies.length; i++) {
+            if (policies[i].is_default_policy) {
+                return await PasswordPolicies.getPolicies(this.dc, policies[i].policy_id);
+            }
+        }
+    }
+    async generateTemplate() {
+        let template;
+        if (this.templateId !== undefined) {
+            try {
+                template = await PasswordTypes.getPasswordTypes(this.dc, this.templateId);
+                template = template[this.templateId];
+            }
+            catch (e) {
+                console.log(i18nText.getI18nMsg("vault.generate.templateId_invalid"));
+            }
+        }
+        if (template === undefined) {
+            const pTypes = await PasswordTypes.getPasswordTypes(this.dc, undefined, undefined, true);
+            const arr = this.formatTypesForTable(pTypes);
+            this.templateId =
+                arr[(await Utilites.selectionPrompt(1, arr.length, i18nText.getI18nMsg("vault.selectionPrompt.Category"))) - 1]["Category ID"]; //NO I18N
+            template = pTypes[this.templateId];
+        }
+        let secretData = template.secret_type_fields;
+        for (let i = 0; i < secretData.length; i++) {
+            let field = secretData[i];
+            field.value = "";
+            delete field.pii;
+            delete field.columnOrder;
+            delete field.isDeleted;
+            delete field.isMandatory;
+        }
+        const secret = {
+            secretname: "",
+            classification: "P|E",
+            description: "",
+            secreturls: [""],
+            secrettypeid: this.templateId,
+            secretdata: secretData,
+            // chamberid: "",
+            tags: "(comma separated)",
+            securenote: "",
+            customcolumnnew: [
+                {
+                    colname: "",
+                    value: "",
+                    type: "file",
+                },
+                {
+                    colname: "",
+                    value: "",
+                    type: "text",
+                },
+                {
+                    colname: "",
+                    value: "",
+                    type: "password",
+                },
+            ],
+        };
+        if (this.format === "xml") {
+            Utilites.printAsXML({ secret }, this.outFile);
+        }
+        else if (this.format === "yaml") {
+            Utilites.printAsYML({ secret }, this.outFile);
+        }
+        else {
+            Utilites.printAsJSON(secret, this.outFile);
+        }
+    }
+    async generate() {
+        await this.getDcAndSetHeader();
+        this.masterKey = await this.getMasterKeyAfterConfiguration();
+        if (this.type === "template") {
+            await this.generateTemplate();
+        }
+        else {
+            await this.generatePassword();
+        }
+    }
+}
+//# sourceMappingURL=Generate.js.map

package/out/old/Get.js

@@ -0,0 +1,225 @@
+import { Login } from "./Login.js";
+import { _pull, Utilites } from "./index.js";
+import { Utilities } from "../util/index.util.js";
+// import { header } from "../commands/login/login.utils.js";
+import { PasswordTypes } from "./PasswordTypes.js";
+import { I18N } from "../js/I18n/index.js";
+import wrap from "word-wrap";
+import Table from "cli-table3";
+import chalk from "chalk";
+import { VAULT_ENDPOINTS } from "../util/consts.util.js";
+import path from "node:path";
+import fs from "node:fs";
+let i18nText;
+export class Get extends Login {
+    constructor(passId, outFile, output, notSafe) {
+        super();
+        this.passId = passId;
+        this.outFile = outFile;
+        this.output = output;
+        this.notSafe = notSafe;
+        i18nText = new I18N();
+        if (outFile !== undefined && typeof outFile === "string") {
+            const dirPath = path.parse(outFile).dir;
+            if ((outFile === undefined || outFile === '' || fs.existsSync(dirPath) || dirPath === '')) {
+                this.outFile = outFile;
+            }
+            else {
+                console.log(chalk.red('Invalid File Path provided'));
+                this.outFile = undefined;
+            }
+        }
+        else {
+            this.outFile = undefined;
+        }
+    }
+    formatDataForTable(secret) {
+        const table = new Table({ head: [
+                i18nText.getI18nMsg("vault.get.formatDataForTable_head_label"),
+                i18nText.getI18nMsg("vault.get.formatDataForTable_head_value")
+            ],
+            style: { head: ['blue', 'bold'], border: ['grey'] }, //NO I18N
+            wordWrap: true,
+            wrapWords: true });
+        table.push([
+            i18nText.getI18nMsg("vault.get.formatDataForTable_body_passwordId_label"),
+            wrap(secret.secretid)
+        ]);
+        if (secret.decsecretname != undefined) {
+            table.push([
+                i18nText.getI18nMsg("vault.get.formatDataForTable_body_passwordName_label"), //No I18N
+                wrap(secret.decsecretname)
+            ]);
+        }
+        else {
+            table.push([
+                i18nText.getI18nMsg("vault.get.formatDataForTable_body_passwordName_label"),
+                wrap(secret.secretname)
+            ]);
+        }
+        if (secret.decdescription != undefined) {
+            table.push([
+                i18nText.getI18nMsg("vault.get.formatDataForTable_body_description_label"), //No I18N
+                wrap(secret.decdescription)
+            ]);
+        }
+        else {
+            table.push([
+                i18nText.getI18nMsg("vault.get.formatDataForTable_body_description_label"),
+                wrap(secret.description)
+            ]);
+        }
+        table.push([
+            i18nText.getI18nMsg("vault.get.formatDataForTable_body_classification_label"),
+            wrap(secret.classification),
+        ]);
+        if (secret.decryptedurls != undefined) {
+            table.push([
+                i18nText.getI18nMsg("vault.get.formatDataforTable_body_URL_label"), //No I18N
+                wrap(secret.decryptedurls)
+            ]);
+        }
+        else {
+            table.push([
+                i18nText.getI18nMsg("vault.get.formatDataforTable_body_URL_label"),
+                wrap(secret.secreturl)
+            ]);
+        }
+        for (let i = 0; i < secret.secretData.length; i++) {
+            const secretDataField = secret.secretData[i];
+            let id = secretDataField["id"];
+            let label = secretDataField["label"];
+            if (id === "username") {
+                id = i18nText.getI18nMsg("vault.get.formatDataForTable_body_username_id");
+                label = i18nText.getI18nMsg("vault.get.formatDataForTable_body_username_label");
+            }
+            else if (id === "password") {
+                id = i18nText.getI18nMsg("vault.get.formatDataForTable_body_password_id");
+                label = i18nText.getI18nMsg("vault.get.formatDataForTable_body_password_label");
+            }
+            else if (id === "file") { //File Attachments 
+                label = i18nText.getI18nMsg("vault.get.formatDataForTable_body_file_label");
+            }
+            else if (id === "agency") { //Health Care Agency
+                id = i18nText.getI18nMsg("vault.get.formatDataForTable_body_agency_id");
+                label = i18nText.getI18nMsg("vault.get.formatDataForTable_body_agency_label");
+            }
+            else if (id === "policyno") { //Health Care Agency
+                id = i18nText.getI18nMsg("vault.get.formatDataForTable_body_policyno_id");
+                label = i18nText.getI18nMsg("vault.get.formatDataForTable_body_policyno_label");
+            }
+            else if (id === "groupno") { //Health care Agency
+                id = i18nText.getI18nMsg("vault.get.formatDataForTable_body_groupno_id");
+                label = i18nText.getI18nMsg("vault.get.formatDataForTable_body_groupno_label");
+            }
+            else if (id === "name") { //category :- Social Security Account
+                id = i18nText.getI18nMsg("vault.get.formatDataTable_body_name_id");
+                label = i18nText.getI18nMsg("vault.get.formatDataTable_body_name_label");
+            }
+            else if (id === "ssno") { // Social Security Account
+                id = i18nText.getI18nMsg("vault.get.formatDataTable_body_ssno_id");
+                label = i18nText.getI18nMsg("vault.get.formatDataTable_body_ssno_label");
+            }
+            else if (id === "accno") { //Bank Account
+                id = i18nText.getI18nMsg("vault.get.formatDataTable_body_accno_id");
+                label = i18nText.getI18nMsg("vault.get.formatDataTable_body_accno_label");
+            }
+            else if (id === "bankid") { //Bank Account
+                id = i18nText.getI18nMsg("vault.get.formatDataTable_body_bankid_id");
+                label = i18nText.getI18nMsg("vault.get.formatDataTable_body_bankid_label");
+            }
+            table.push([
+                label,
+                wrap(secretDataField.value),
+            ]);
+        }
+        if (secret.customcolumn !== undefined) {
+            for (let i = 0; i < secret.customcolumn.customcol.length; i++) {
+                const customcolElement = secret.customcolumn.customcol[i];
+                table.push([
+                    wrap(customcolElement.colname),
+                    customcolElement.type === "file" ? wrap(secret.files[customcolElement.value]) : wrap(customcolElement.value, { width: 10 })
+                ]);
+            }
+        }
+        table.push([
+            i18nText.getI18nMsg("vault.get.formatDataForTable_body_ownername_label"),
+            wrap(secret.ownerdetails.USERNAME)
+        ]);
+        table.push([
+            i18nText.getI18nMsg("vault.get.formatDataForTable_body_owneremail_label"),
+            wrap(secret.ownerdetails.EMAIL)
+        ]);
+        table.push([
+            i18nText.getI18nMsg("vault.get.formatDataForTable_body_securenote_label"),
+            wrap(secret.notes)
+        ]);
+        console.log(table.toString());
+    }
+    static async getPasswrd(dc, passId) {
+        let passDetResp = await _pull(`${Utilites.getVaultUrl(dc)}${VAULT_ENDPOINTS.URL_SECRETS}/${passId}`);
+        return passDetResp.data;
+    }
+    static formatFilesArr(files) {
+        const filesArr = JSON.parse(files);
+        let filesObj = {};
+        for (let i = 0; i < filesArr.length; i++) {
+            const file = filesArr[i];
+            filesObj[file.column] = file.name;
+        }
+        return filesObj;
+    }
+    attachColInfoWithSecData(secData, colInfo) {
+        colInfo.forEach((col) => {
+            col.value = secData[col["name"]];
+        });
+    }
+    async getPassWithId() {
+        const { result, Details: password } = (await Get.getPasswrd(this.dc, this.passId)).operation;
+        if (result.status !== "Success") {
+            console.log(i18nText.getI18nMsg("vault.get.getPassWithId_notSuccess"));
+            console.log(result.message);
+            process.exit(1);
+        }
+        const template = await PasswordTypes.getPasswordTypes(this.dc, password.accounttype);
+        await this.decryptSecretObj(password, this.notSafe, template[password.accounttype]);
+        // this.attachColInfoWithSecData(password.secretData, template[password.accounttype].secret_type_fields);
+        // password.secretData = template[password.accounttype].secret_type_fields;
+        password.files = password.files === undefined ? {} : Get.formatFilesArr(password.files);
+        for (let i = 0; i < password.secretData.length; i++) {
+            let secretDataFeild = password.secretData[i];
+            delete secretDataFeild.pii;
+            delete secretDataFeild.columnOrder;
+            delete secretDataFeild.isDeleted;
+            delete secretDataFeild.isMandatory;
+            secretDataFeild.id = secretDataFeild.name;
+            if (secretDataFeild.type === "file") {
+                secretDataFeild.value = password.files[secretDataFeild.value];
+            }
+            delete secretDataFeild.name;
+        }
+        if (this.output === "xml") {
+            Utilities.printAsXML({ secret: password }, this.outFile, "xml");
+        }
+        else if (this.output === "yml" || this.output === "yaml") {
+            Utilities.printAsYAML({ secret: password }, this.outFile, this.output);
+        }
+        else if (this.output === "json") {
+            Utilities.printAsJSON({ secret: password }, this.outFile, "json");
+        }
+        else {
+            if (this.outFile !== undefined) {
+                console.log(chalk.red.bold(i18nText.getI18nMsg("vault.get.cantSaveTable")));
+            }
+            this.formatDataForTable(password);
+        }
+    }
+    async get() {
+        await this.getDcAndSetHeader();
+        this.masterKey = await this.getMasterKeyAfterConfiguration();
+        if (this.passId !== undefined) {
+            await this.getPassWithId();
+        }
+    }
+}
+//# sourceMappingURL=Get.js.map