@zohocorporation/vault-cli 1.1.2

package/out/old/Update.js

@@ -0,0 +1,682 @@
+import { Login } from "./Login.js";
+import { Get } from "./Get.js";
+import { PasswordTypes } from "./PasswordTypes.js";
+import { Utilites, _pull } from "./index.js";
+// import { _pull, Utilities } from "../util/index.util.js";
+// import { header } from "../commands/login/login.utils.js";
+import Vault from "../js/crypto/index.js";
+import { I18N } from "../js/I18n/index.js";
+//import { _pull, urlSecrets,urlV2Secrets, Utilites } from "./index";
+import inquirer from "inquirer";
+import fs from "node:fs";
+import { Logger } from "../js/logger/index.js";
+import path from "node:path";
+import chalk from "chalk";
+import * as mime from "mime-types";
+import { VAULT_ENDPOINTS } from "../util/consts.util.js";
+// var mime = require('mime-types')
+let i18nText;
+export class Update extends Login {
+    constructor(id, input) {
+        super();
+        if (input !== undefined) {
+            this.input = JSON.parse(input);
+        }
+        this.id = id;
+        i18nText = new I18N();
+    }
+    async update() {
+        await this.getDcAndSetHeader();
+        this.masterKey = await this.getMasterKeyAfterConfiguration();
+        let { result, Details: password } = (await Get.getPasswrd(this.dc, this.id)).operation;
+        if (result.status !== "Success") {
+            process.exit(1);
+        }
+        // console.log("result: ", result, "password: ", password);
+        const template = await PasswordTypes.getPasswordTypes(this.dc, password.accounttype);
+        await this.decryptSecretObj(password, template[password.accounttype], true);
+        if (this.input.notes !== undefined) {
+            password.notes = this.input.notes;
+        }
+        delete password.creationtime;
+        delete password.secretTypeName;
+        delete password.passwordmodifiedtime;
+        delete password.sharinglevel;
+        delete password.onetimeacess;
+        delete password.autosubmit;
+        delete password.isfavourites;
+        delete password.displayaccctrlicon;
+        delete password.ownerdetails;
+        delete password.userid;
+        delete password.accesssctrlconfigured;
+        delete password.POLICYID;
+        password.secreturls = password.secretmultipleurl;
+        delete password.secretmultipleurl;
+        password.securenote = password.notes;
+        password.secrettypeid = password.accounttype;
+        delete password.notes;
+        delete password.accounttype;
+        for (const id in this.input) {
+            if (password[id] !== undefined) {
+                if (id === "secretname") {
+                    const validation = Utilites.XSSValidatorWithMand(this.input[id]);
+                    if (typeof validation === "string") {
+                        console.log(id, validation);
+                        process.exit(1);
+                    }
+                    else {
+                        password[id] = this.input[id];
+                    }
+                }
+                else if (id === "classification") {
+                    if (this.input[id].toUpperCase() === "E" ||
+                        this.input[id].toUpperCase() === "P") {
+                        password[id] = this.input[id].toUpperCase();
+                    }
+                    else {
+                        console.log(chalk.red(i18nText.getI18nMsg("vault.update.classification_allowedValues")));
+                        process.exit(1);
+                    }
+                }
+                else {
+                    const validation = Utilites.XSSValidator(this.input[id]);
+                    if (typeof validation === "string") {
+                        console.log(id, validation);
+                        process.exit(1);
+                    }
+                    else {
+                        password[id] = this.input[id];
+                    }
+                }
+                delete this.input[id];
+            }
+        }
+        let key = password.isshared === "YES" ? await this.getOrgKey() : this.masterKey;
+        const oldvalues = {};
+        for (const id in this.input) {
+            for (let i = 0; i < password.secretData.length; i++) {
+                let secretField = password.secretData[i];
+                if (secretField.name === id) {
+                    if (secretField.type === "file") {
+                        console.log(i18nText.getI18nMsg("vault.update.fileUpdate_notSupported"));
+                        process.exit(1);
+                    }
+                    else if (secretField.type === "password") {
+                        if (secretField.isMandatory) {
+                            if (this.input[id].trim() === "") {
+                                console.log(id, i18nText.getI18nMsg("vault.update.mand_emptyFields"));
+                                process.exit(1);
+                            }
+                            oldvalues[secretField.name] = Vault.encrypt(secretField.value, key);
+                            secretField.value = this.input[id];
+                        }
+                    }
+                    else {
+                        if (secretField.isMandatory) {
+                            const validation = Utilites.XSSValidatorWithMand(this.input[id]);
+                            if (typeof validation === "string") {
+                                console.log(id, validation);
+                                process.exit(1);
+                            }
+                        }
+                        else {
+                            const validation = Utilites.XSSValidator(this.input[id]);
+                            if (typeof validation === "string") {
+                                console.log(id, validation);
+                                process.exit(1);
+                            }
+                        }
+                        secretField.value = this.input[id];
+                    }
+                }
+            }
+        }
+        delete password.old_values;
+        for (const id in this.input) {
+            for (let i = 0; i < password.customcolumn.customcol.length; i++) {
+                let customcolElement = password.customcolumn.customcol[i];
+                if (customcolElement.id === id) {
+                    if (this.input[id].trim() === "") {
+                        console.log(id, i18nText.getI18nMsg("vault.update.customCol_emptyField"));
+                        process.exit(1);
+                    }
+                    if (customcolElement.type === "file") {
+                        console.log(i18nText.getI18nMsg("vault.update.fileUpdate_notSupported"));
+                        process.exit(1);
+                    }
+                    else if (customcolElement.type === "password") {
+                        const validation = Utilites.XSSValidator(this.input[id]);
+                        if (typeof validation === "string") {
+                            console.log(id, validation);
+                            process.exit(1);
+                        }
+                        customcolElement.value = this.input[id];
+                    }
+                    else {
+                        const validation = Utilites.XSSValidator(this.input[id]);
+                        if (typeof validation === "string") {
+                            console.log(id, validation);
+                            process.exit(1);
+                        }
+                        customcolElement.value = this.input[id];
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < password.customcolumn.customcol.length; i++) {
+            let customcolElement = password.customcolumn.customcol[i];
+            customcolElement.value = Vault.encrypt(customcolElement.value, key);
+        }
+        let formattedSecretData = {};
+        for (let i = 0; i < password.secretData.length; i++) {
+            let secretDataField = password.secretData[i];
+            formattedSecretData[secretDataField.name] = Vault.encrypt(secretDataField.value, key);
+        }
+        password.oldvalues = oldvalues;
+        password.secretdata = formattedSecretData;
+        delete password.secretData;
+        const secretId = password.secretid;
+        password.secret_auto_id = password.secretid;
+        delete password.secretid;
+        password.customcolumnnew = Vault.Base64_encode(JSON.stringify(password.customcolumn));
+        delete password.files;
+        delete password.autologon;
+        delete password.customcolumn;
+        delete password.lastmodifiedtime;
+        delete password.changepassword;
+        delete password.issharedtousers;
+        delete password.sharingtype;
+        password.securenote = Vault.encrypt(password.securenote, key);
+        password = { INPUT_DATA: JSON.stringify(password) };
+        const secretResp = await _pull(`${Utilites.getVaultUrl(this.dc)}${VAULT_ENDPOINTS.URL_SECRETS}/${secretId}`, password, "PUT");
+        if (secretResp.data.operation.result.status === "Success") {
+            console.log(i18nText.getI18nMsg("vault.update.updateSuccess"));
+        }
+        else {
+            console.log(secretResp.data.operation.result.status);
+            console.log(secretResp.data.operation.result.message);
+        }
+    }
+    async interactiveUpdate() {
+        await this.getDcAndSetHeader();
+        this.masterKey = await this.getMasterKeyAfterConfiguration();
+        let { result, Details: password } = (await Get.getPasswrd(this.dc, this.id)).operation;
+        if (result.status !== "Success") {
+            console.log(result.message);
+            process.exit(1);
+        }
+        const template = await PasswordTypes.getPasswordTypes(this.dc, password.accounttype);
+        // console.log("Templete: ", template);
+        await this.decryptSecretObj(password, true, template[password.accounttype]);
+        let fileCount = 0;
+        if (password.files !== undefined) {
+            password.files = JSON.parse(password.files);
+            fileCount = password.files.length;
+        }
+        let key = password.isshared === "YES" ? await this.getOrgKey() : this.masterKey;
+        const updateCol = [{ name: "notes", type: "input", label: "Notes" }, { name: "description", type: "input", label: "Description" }, { name: "secreturl", type: "input", label: "URL" }, { name: "secretname", type: "input", label: "Password Name" }, { name: "tags", type: "input", label: "Tags" }, { name: "classification", type: "input", label: "Classification" }];
+        let mandFields = ["secretname"];
+        let secretFields = {}; // secret fields present
+        for (let i in password.secretData) {
+            let type = password.secretData[i].type;
+            if (type === "text") {
+                type = "input";
+            }
+            secretFields[password.secretData[i].name] = password.secretData[i].value;
+            updateCol.push({ name: password.secretData[i].name, type: type, label: password.secretData[i].label });
+            if (password.secretData[i].isMandatory === true) {
+                mandFields.push(password.secretData[i].name);
+            }
+        }
+        let answer = await inquirer.prompt([{
+                name: "colUpdate",
+                type: "checkbox",
+                loop: false,
+                message: i18nText.getI18nMsg("vault.update.updateCol"),
+                choices: function () {
+                    let colOptions = [];
+                    for (let col in updateCol) {
+                        colOptions.push({
+                            name: updateCol[col].label,
+                            value: updateCol[col]
+                        });
+                    }
+                    return colOptions;
+                }
+            }]);
+        let customColAnswer = false;
+        if (password.customcolumn !== undefined && password.customcolumn.customcol.length > 0) {
+            customColAnswer = await inquirer.prompt([{
+                    name: "answer",
+                    type: "list", //NO I18N
+                    message: i18nText.getI18nMsg("vault.update.updatecustomCol"), //NO I18N
+                    choices: [
+                        { name: 'Yes', value: true }, //NO I18N
+                        { name: 'No', value: false } //NO I18N
+                    ],
+                    default: true
+                }]);
+            customColAnswer = customColAnswer.answer;
+        }
+        let customColPrompt = [];
+        let updatePassword = { INPUT_DATA: {} };
+        let setCustomCol = {};
+        if (customColAnswer) {
+            for (let i in password.customcolumn.customcol) {
+                setCustomCol[password.customcolumn.customcol[i].id] = password.customcolumn.customcol[i];
+                let type = password.customcolumn.customcol[i].type;
+                if (type === "text") {
+                    type = "input";
+                }
+                else if (type === "password") {
+                    type = 'password';
+                }
+                customColPrompt.push({
+                    name: password.customcolumn.customcol[i].id,
+                    type: type,
+                    mask: type === 'password' ? '*' : null, //No I18N
+                    message: "Update Value for " + password.customcolumn.customcol[i].colname + "(" + password.customcolumn.customcol[i].id + ")", //No I18N
+                    default: password.customcolumn.customcol[i].value,
+                    validate: async function (value) {
+                        if (type === 'file') {
+                            if (value !== password.customcolumn.customcol[i].value && fs.existsSync(value) && fs.statSync(value).isFile()) {
+                                if (fs.existsSync(value) && fs.statSync(value).isFile()) {
+                                    let fileStats = fs.statSync(value);
+                                    let data = 'data:' + mime.lookup(value) + ';base64,' + fs.readFileSync(value, 'base64').toString();
+                                    if (updatePassword.INPUT_DATA.deletedFiles === undefined) {
+                                        updatePassword.INPUT_DATA.deletedFiles = [];
+                                    }
+                                    updatePassword.INPUT_DATA.deletedFiles.push(password.customcolumn.customcol[i].value);
+                                    fileCount = fileCount - 1;
+                                    if (updatePassword.INPUT_DATA.files === undefined) {
+                                        updatePassword.INPUT_DATA.files = [];
+                                    }
+                                    updatePassword.INPUT_DATA.files.push({
+                                        name: path.basename(value),
+                                        column: password.customcolumn.customcol[i].value,
+                                        size: fileStats.size,
+                                        data: Vault.fileEncrypt(data, key)
+                                    });
+                                }
+                            }
+                            else {
+                                return i18nText.getI18nMsg("vault.update.file_doesntExit");
+                            }
+                        }
+                        return true;
+                    }
+                });
+            }
+        }
+        let keysecretFields = []; //secret field to update
+        const keysToUpdate = answer.colUpdate;
+        let updateVal = [];
+        for (let i in keysToUpdate) {
+            if (Object.keys(secretFields).includes(keysToUpdate[i].name)) {
+                keysecretFields.push(keysToUpdate[i].name);
+            }
+            if (keysToUpdate[i].name === 'tags') {
+                updateVal.push({
+                    type: 'input',
+                    name: 'add_tags',
+                    message: 'Add New Tags (Comma seperated) :',
+                    default: ""
+                }, {
+                    type: 'input',
+                    name: 'remove_tags',
+                    message: 'Remove Existing Tags (Comma seperated) :',
+                    default: ""
+                });
+            }
+            else {
+                updateVal.push({
+                    type: keysToUpdate[i].name === 'classification' ? 'list' : keysToUpdate[i].type,
+                    name: keysToUpdate[i].name,
+                    mask: keysToUpdate[i].type === 'password' ? '*' : null,
+                    message: "Update Value for " + keysToUpdate[i].label,
+                    default: keysToUpdate[i].name === 'tags' ? password.tags : null,
+                    choices: function () {
+                        if (keysToUpdate[i].name === 'classification') {
+                            return [{ name: 'Personal', value: 'P' }, { name: 'Enterprise', value: 'E' }];
+                        }
+                    },
+                    validate: async function (value) {
+                        if (keysToUpdate[i].type === "file") {
+                            try {
+                                if (fs.existsSync(value) && fs.statSync(value).isFile()) {
+                                    let fileStats = fs.statSync(value);
+                                    let data = 'data:' + mime.lookup(value) + ';base64,' + fs.readFileSync(value, 'base64').toString();
+                                    if (password.files === undefined) {
+                                        updatePassword.INPUT_DATA.files = [];
+                                        updatePassword.INPUT_DATA.files.push({
+                                            name: path.basename(value),
+                                            column: "file",
+                                            size: fileStats.size,
+                                            data: Vault.fileEncrypt(data, key)
+                                        });
+                                    }
+                                    else {
+                                        for (let file in password.files) {
+                                            if (password.files[file].column === "file") {
+                                                fileCount = fileCount - 1;
+                                                if (updatePassword.INPUT_DATA.deletedFiles === undefined) {
+                                                    updatePassword.INPUT_DATA.deletedFiles = ["file"];
+                                                }
+                                                else {
+                                                    updatePassword.INPUT_DATA.deletedFiles.push("file");
+                                                }
+                                                break;
+                                            }
+                                        }
+                                        if (updatePassword.INPUT_DATA.files === undefined || updatePassword.INPUT_DATA.files.length === 0) {
+                                            updatePassword.INPUT_DATA.files = [];
+                                        }
+                                        updatePassword.INPUT_DATA.files.push({
+                                            name: path.basename(value),
+                                            column: "file",
+                                            size: fileStats.size,
+                                            data: Vault.fileEncrypt(data, key)
+                                        });
+                                    }
+                                    if (keysToUpdate[i].isMandatory === "true") {
+                                        return Utilites.mandFileValidator(value);
+                                    }
+                                    else {
+                                        return Utilites.FileValidator(value);
+                                    }
+                                }
+                                else {
+                                    return i18nText.getI18nMsg("vault.update.file_doesntExit");
+                                }
+                            }
+                            catch (e) {
+                                Logger.error(e);
+                            }
+                        }
+                        else {
+                            if (mandFields.includes(keysToUpdate[i].name)) {
+                                if (keysToUpdate[i].type === 'password') {
+                                    return Utilites.passwordMandValidator(value);
+                                }
+                                else {
+                                    return Utilites.mandValidator(value);
+                                }
+                            }
+                            return true;
+                        }
+                    },
+                    filter: function (value) {
+                        if (keysToUpdate[i].type !== "password") {
+                            value = Utilites.trimText(value);
+                        }
+                        return value;
+                    }
+                });
+            }
+        }
+        updateVal = await inquirer.prompt(updateVal);
+        let customColUpdateAnswer = await inquirer.prompt(customColPrompt);
+        let passwordmodified = false;
+        if (keysecretFields.includes("password")) {
+            passwordmodified = true;
+        }
+        updatePassword.INPUT_DATA.passwordmodified = passwordmodified;
+        updatePassword.INPUT_DATA.secretdata = {};
+        updatePassword.INPUT_DATA.oldvalues = {};
+        if (password.notes !== undefined) {
+            if (updateVal.notes === undefined) {
+                updatePassword.INPUT_DATA.securenote = Vault.encrypt(password.notes, key);
+            }
+            else {
+                updatePassword.INPUT_DATA.securenote = Vault.encrypt(updateVal.notes, key);
+            }
+        }
+        let keyfield = Object.keys(secretFields);
+        for (let field in keyfield) {
+            if (updateVal[keyfield[field]] === undefined) {
+                updatePassword.INPUT_DATA.secretdata[keyfield[field]] = Vault.encrypt(secretFields[keyfield[field]], key);
+            }
+            else {
+                if (keyfield[field] === "file") {
+                    updatePassword.INPUT_DATA.secretdata[keyfield[field]] = Vault.encrypt("file", key);
+                }
+                else {
+                    updatePassword.INPUT_DATA.oldvalues[keyfield[field]] = Vault.encrypt(secretFields[keyfield[field]], key);
+                    updatePassword.INPUT_DATA.secretdata[keyfield[field]] = Vault.encrypt(updateVal[keyfield[field]], key);
+                }
+            }
+        }
+        updatePassword.INPUT_DATA.secrettypeid = password.accounttype;
+        updatePassword.INPUT_DATA.classification = updateVal.classification === undefined ? password.classification : updateVal.classification;
+        updatePassword.INPUT_DATA.secretname = updateVal.secretname === undefined ? password.secretname : updateVal.secretname;
+        updatePassword.INPUT_DATA.isshared = password.isshared;
+        let secreturls = [];
+        if (updateVal.secreturl !== undefined) {
+            secreturls = updateVal.secreturl.split(",");
+        }
+        updatePassword.INPUT_DATA.secreturls = secreturls;
+        updatePassword.INPUT_DATA.customcolumnnew = {};
+        updatePassword.INPUT_DATA.customcolumnnew.customcol = [];
+        if (customColAnswer) {
+            for (let col in customColUpdateAnswer) {
+                if (setCustomCol[col].type === 'file') {
+                    for (let file in updatePassword.INPUT_DATA.files) {
+                        if (updatePassword.INPUT_DATA.files[file].name === path.basename(customColUpdateAnswer[col])) {
+                            setCustomCol[col].value = Vault.encrypt(updatePassword.INPUT_DATA.files[file].column, key);
+                        }
+                    }
+                }
+                else {
+                    setCustomCol[col].value = Vault.encrypt(customColUpdateAnswer[col], key);
+                }
+            }
+        }
+        else {
+            if (password.customcolumn != undefined) {
+                for (let col in password.customcolumn.customcol) {
+                    setCustomCol[col] = password.customcolumn.customcol[col];
+                    setCustomCol[col].value = Vault.encrypt(password.customcolumn.customcol[col].value, key);
+                }
+            }
+        }
+        if (setCustomCol != null) {
+            for (let col in setCustomCol) {
+                updatePassword.INPUT_DATA.customcolumnnew.customcol.push(setCustomCol[col]);
+            }
+        }
+        let cusColPrompt = {
+            type: "list", //No I18N
+            name: "customcolumnnew", //No I18N
+            message: i18nText.getI18nMsg("vault.add.interactiveAdd_addCustomCol"), //No I18N
+            choices: [
+                { name: 'Yes', value: true }, //No I18N
+                { name: 'No', value: false } //No I18N
+            ],
+            default: true
+        };
+        let customColType = {
+            type: "list", //No I18N
+            name: "type", //No I18N
+            message: i18nText.getI18nMsg("vault.add.interactiveAdd_colType"), //No I18N
+            choices: [
+                { name: i18nText.getI18nMsg("vault.add.interactiveAdd_option_colType_file"), value: "file" }, //No I18N
+                { name: i18nText.getI18nMsg("vault.add.interactiveAdd_option_colType_text"), value: "text" }, //No I18N
+                { name: i18nText.getI18nMsg("vault.add.interactiveAdd_option_colType_password"), value: "password" } //No I18N
+            ]
+        };
+        let ans = [];
+        while ((await inquirer.prompt(cusColPrompt)).customcolumnnew) {
+            let customType = await inquirer.prompt(customColType);
+            let custom_col = [
+                {
+                    type: "input", //No I18N
+                    name: "colname", //No I18N
+                    message: i18nText.getI18nMsg("vault.add.interactiveAdd_customCol_name"), //No I18N
+                    validate: Utilites.mandValidator,
+                    filter: Utilites.trimText
+                },
+                {
+                    type: customType.type === "password" ? "password" : "input",
+                    mask: customType.type === 'password' ? '*' : null,
+                    name: "value", //No I18N
+                    message: i18nText.getI18nMsg("vault.add.interactiveAdd_customCol_value"), //No I18N
+                    validate: function (value) {
+                        if (customType.type === "file") {
+                            if (fs.existsSync(value) && fs.statSync(value).isFile()) {
+                                return Utilites.mandFileValidator(value);
+                            }
+                            else {
+                                return i18nText.getI18nMsg("vault.update.file_doesntExit");
+                            }
+                        }
+                        else {
+                            return true;
+                        }
+                    },
+                    filter: function (ans) {
+                        if (customType.type !== "password") {
+                            return Utilites.trimText(ans);
+                        }
+                        return ans;
+                    }
+                }
+            ];
+            custom_col = await inquirer.prompt(custom_col);
+            custom_col.type = customType.type;
+            ans.push(custom_col);
+        }
+        if (ans.length > 0) {
+            if (updatePassword.INPUT_DATA.customcolumnnew === undefined) {
+                updatePassword.INPUT_DATA.customcolumnnew = {};
+                updatePassword.INPUT_DATA.customcolumnnew.customcol = [];
+            }
+            else if (updatePassword.INPUT_DATA.customcolumnnew.customcol === undefined) {
+                updatePassword.INPUT_DATA.customcolumnnew.customcol = [];
+            }
+            let index = 0;
+            const prefix_col = "custColDiv_"; //No I18N
+            let fileIndex = 0;
+            const filePrefix = "customattrivalue_"; //No I18N
+            if (password.customcolumn !== undefined && password.customcolumn.customcol !== undefined) {
+                if (password.customcolumn.customcol.length > 0) {
+                    index = parseInt(password.customcolumn.customcol[password.customcolumn.customcol.length - 1].id.slice(11)) + 1;
+                }
+            }
+            if (password.files !== undefined) {
+                for (let i in password.files) {
+                    if (password.files[i].column.startsWith(filePrefix) && fileIndex < parseInt(password.files[i].column.slice(18))) {
+                        fileIndex = parseInt(password.files[i].column.slice(18));
+                    }
+                }
+            }
+            fileIndex = fileIndex + 1;
+            for (let i in ans) {
+                if (ans[i].type === "file") {
+                    let fileStats = fs.statSync(ans[i].value);
+                    const data = 'data:' + mime.lookup(ans[i].value) + ';base64,' + fs.readFileSync(ans[i].value, 'base64').toString();
+                    if (updatePassword.INPUT_DATA.files === undefined || updatePassword.INPUT_DATA.files.length === 0) {
+                        updatePassword.INPUT_DATA.files = [];
+                    }
+                    updatePassword.INPUT_DATA.files.push({
+                        name: path.basename(ans[i].value),
+                        column: filePrefix + fileIndex.toString(),
+                        size: fileStats.size,
+                        data: Vault.fileEncrypt(data, key)
+                    });
+                }
+                ans[i].id = prefix_col + index.toString();
+                updatePassword.INPUT_DATA.customcolumnnew.customcol.push(ans[i]);
+                if (ans[i].type === "file") {
+                    ans[i].value = Vault.encrypt(filePrefix + fileIndex.toString(), key);
+                    fileIndex = fileIndex + 1;
+                }
+                else {
+                    ans[i].value = Vault.encrypt(ans[i].value, key);
+                }
+                index = index + 1;
+            }
+        }
+        if (updatePassword.INPUT_DATA.customcolumnnew !== undefined && updatePassword.INPUT_DATA.customcolumnnew.customcol !== undefined) {
+            updatePassword.INPUT_DATA.customcolumnnew = Vault.Base64_encode(JSON.stringify(updatePassword.INPUT_DATA.customcolumnnew));
+        }
+        if (updateVal.add_tags !== undefined && updateVal.remove_tags !== undefined) {
+            if (password.tags === undefined || password.tags === '') {
+                updatePassword.INPUT_DATA.tags = updateVal.add_tags;
+            }
+            else {
+                updatePassword.INPUT_DATA.tags = password.tags + "," + updateVal.add_tags;
+            }
+            let removeTags = updateVal.remove_tags.split(",");
+            let tagsPresent = updatePassword.INPUT_DATA.tags.split(",");
+            let newTags = tagsPresent.filter(tag => !removeTags.includes(tag));
+            updatePassword.INPUT_DATA.tags = newTags.join(",");
+        }
+        if (updateVal.description !== undefined) {
+            updatePassword.INPUT_DATA.description = updateVal.description;
+        }
+        if (updatePassword.INPUT_DATA.files !== undefined) {
+            fileCount = fileCount + updatePassword.INPUT_DATA.files.length;
+        }
+        // need ecnrypt the non-encrypted files here
+        if (updatePassword.INPUT_DATA.description != '' && updatePassword.INPUT_DATA.description != undefined) {
+            updatePassword.INPUT_DATA.encdescription = Vault.encrypt(updatePassword.INPUT_DATA.description, key);
+        }
+        if (updatePassword.INPUT_DATA.tags != '' && updatePassword.INPUT_DATA.tags != undefined) {
+            updatePassword.INPUT_DATA.encryptedtags = Vault.encrypt(updatePassword.INPUT_DATA.tags, key);
+        } // v2 api
+        if (updatePassword.INPUT_DATA.secreturls.length > 1) {
+            for (let url in updatePassword.INPUT_DATA.secreturls) {
+                updatePassword.INPUT_DATA.encryptedurls[url] = Vault.encrypt(updatePassword.INPUT_DATA.secreturls[url], key);
+            } //v2 api
+        }
+        else {
+            if (updatePassword.INPUT_DATA.secreturls[0] != undefined) {
+                updatePassword.INPUT_DATA.encryptedurls = [Vault.encrypt(updatePassword.INPUT_DATA.secreturls[0], key)];
+            }
+        }
+        updatePassword.INPUT_DATA.encsecretname = Vault.encrypt(updatePassword.INPUT_DATA.secretname, key);
+        let v2_updatePassword = {};
+        let v2_fields = ["passwordmodified", "isshared", "oldvalues", "secretname", "classification", "isshared", "policyid", "secrettypeid", "secretdata", "customcolumnnew", "securenote", "encsecretname", "encdescription", "encryptedtags", "encryptedurls", "files"]; //No I18N
+        for (let fields in v2_fields) {
+            let field = v2_fields[fields];
+            if ((updatePassword.INPUT_DATA[v2_fields[fields]]) != undefined) {
+                v2_updatePassword[field] = updatePassword.INPUT_DATA[v2_fields[fields]];
+            }
+        }
+        updatePassword = { INPUT_DATA: JSON.stringify(updatePassword.INPUT_DATA) };
+        this.sanitizeInput(v2_updatePassword);
+        v2_updatePassword = { INPUT_DATA: JSON.stringify(v2_updatePassword) };
+        if (fileCount > 2) {
+            console.log(chalk.red(i18nText.getI18nMsg("vault.update.file_limit")));
+            process.exit(1);
+        }
+        try {
+            const secretResp = await _pull(`${Utilites.getVaultUrl(this.dc)}${VAULT_ENDPOINTS.URL_V2_SECRETS}/${this.id}`, v2_updatePassword, "PUT");
+            if (secretResp.data.operation.result.status === "Success") {
+                console.log(chalk.green(i18nText.getI18nMsg("vault.update.updateSuccess")));
+            }
+            else {
+                Logger.error(secretResp.data.operation.result);
+                console.log(chalk.red(i18nText.getI18nMsg("vault.update.secrets_errorUpdating")));
+            }
+        }
+        catch (e) {
+            Logger.error(e);
+            console.log(chalk.red(i18nText.getI18nMsg("vault.update.secrets_errorUpdating")));
+        }
+    }
+    sanitizeInput(input) {
+        if (input.files == undefined) {
+            return;
+        }
+        const { files } = input;
+        if (input.deletedFiles !== undefined) {
+            return;
+        }
+        input.deletedFiles = [];
+        for (const file of files) {
+            input.deletedFiles.push(file.column);
+        }
+    }
+}
+//# sourceMappingURL=Update.js.map