@rockcarver/frodo-lib 0.11.0

package/src/ops/ConnectionProfileOps.js

@@ -0,0 +1,254 @@
+import fs from 'fs';
+import os from 'os';
+import storage from '../storage/SessionStorage.js';
+import DataProtection from './utils/DataProtection.js';
+import {
+  createObjectTable,
+  createTable,
+  printMessage,
+} from './utils/Console.js';
+
+const dataProtection = new DataProtection();
+
+const fileOptions = {
+  options: 'utf8',
+  indentation: 4,
+};
+
+const getConnectionProfilesFolder = () => `${os.homedir()}/.frodo`;
+
+/**
+ * Get connection profiles file name
+ * @returns {String} connection profiles file name
+ */
+export function getConnectionProfilesFileName() {
+  return `${os.homedir()}/.frodo/.frodorc`;
+}
+
+/**
+ * Find connection profile
+ * @param {Object} connectionProfiles connection profile object
+ * @param {String} host tenant host url or unique substring
+ * @returns {Object} connection profile object or null
+ */
+function findConnectionProfile(connectionProfiles, host) {
+  for (const tenant in connectionProfiles) {
+    if (tenant.includes(host)) {
+      const profile = connectionProfiles[tenant];
+      profile.tenant = tenant;
+      return profile;
+    }
+  }
+  return null;
+}
+
+/**
+ * List connection profiles
+ * @param {boolean} long Long list format with details
+ */
+export function listConnectionProfiles(long = false) {
+  const filename = getConnectionProfilesFileName();
+  try {
+    const data = fs.readFileSync(filename, 'utf8');
+    const connectionsData = JSON.parse(data);
+    if (long) {
+      const table = createTable(['Host', 'Username', 'Log API Key']);
+      Object.keys(connectionsData).forEach((c) => {
+        table.push([
+          c,
+          connectionsData[c].username,
+          connectionsData[c].logApiKey,
+        ]);
+      });
+      printMessage(table.toString(), 'data');
+    } else {
+      Object.keys(connectionsData).forEach((c) => {
+        printMessage(`${c}`, 'data');
+      });
+    }
+    printMessage(
+      'Any unique substring of a saved host can be used as the value for host parameter in all commands',
+      'info'
+    );
+  } catch (e) {
+    printMessage(`No connections found in ${filename} (${e.message})`, 'error');
+  }
+}
+
+/**
+ * Initialize connection profiles
+ */
+export function initConnectionProfiles() {
+  // create connections.json file if it doesn't exist
+  const folderName = getConnectionProfilesFolder();
+  const filename = getConnectionProfilesFileName();
+  if (!fs.existsSync(folderName)) {
+    fs.mkdirSync(folderName, { recursive: true });
+    if (!fs.existsSync(filename)) {
+      fs.writeFileSync(
+        filename,
+        JSON.stringify({}, null, fileOptions.indentation)
+      );
+    }
+  }
+  // encrypt the password from clear text to aes-256-GCM
+  else {
+    const data = fs.readFileSync(filename, fileOptions.options);
+    const connectionsData = JSON.parse(data);
+    let convert = false;
+    Object.keys(connectionsData).forEach(async (conn) => {
+      if (connectionsData[conn].password) {
+        convert = true;
+        connectionsData[conn].encodedPassword = await dataProtection.encrypt(
+          connectionsData[conn].password
+        ); // Buffer.from(connectionsData[conn].password).toString('base64');
+        delete connectionsData[conn].password;
+      }
+    });
+    if (convert) {
+      fs.writeFileSync(
+        filename,
+        JSON.stringify(connectionsData, null, fileOptions.indentation)
+      );
+    }
+  }
+}
+
+/**
+ * Get connection profile by host
+ * @param {String} host host tenant host url or unique substring
+ * @returns {Object} connection profile or null
+ */
+export async function getConnectionProfileByHost(host) {
+  try {
+    const filename = getConnectionProfilesFileName();
+    const connectionsData = JSON.parse(
+      fs.readFileSync(filename, fileOptions.options)
+    );
+    const profile = findConnectionProfile(connectionsData, host);
+    if (!profile) {
+      printMessage(
+        `Profile for ${host} not found. Please specify credentials on command line`,
+        'error'
+      );
+      return null;
+    }
+    return {
+      tenant: profile.tenant,
+      username: profile.username ? profile.username : null,
+      password: profile.encodedPassword
+        ? await dataProtection.decrypt(profile.encodedPassword)
+        : null,
+      key: profile.logApiKey ? profile.logApiKey : null,
+      secret: profile.logApiSecret ? profile.logApiSecret : null,
+    };
+  } catch (e) {
+    printMessage(
+      `Can not read saved connection info, please specify credentials on command line: ${e}`,
+      'error'
+    );
+    return null;
+  }
+}
+
+/**
+ * Get connection profile
+ * @returns {Object} connection profile or null
+ */
+export async function getConnectionProfile() {
+  return getConnectionProfileByHost(storage.session.getTenant());
+}
+
+/**
+ * Save connection profile
+ */
+export async function saveConnectionProfile() {
+  const filename = getConnectionProfilesFileName();
+  printMessage(`Saving creds in ${filename}...`);
+  let connectionsData = {};
+  let existingData = {};
+  try {
+    fs.statSync(filename);
+    const data = fs.readFileSync(filename, 'utf8');
+    connectionsData = JSON.parse(data);
+    if (connectionsData[storage.session.getTenant()]) {
+      existingData = connectionsData[storage.session.getTenant()];
+      printMessage(
+        `Updating existing connection profile ${storage.session.getTenant()}`
+      );
+    } else
+      printMessage(`Adding connection profile ${storage.session.getTenant()}`);
+  } catch (e) {
+    printMessage(
+      `Creating connection profile file ${filename} with ${storage.session.getTenant()}`
+    );
+  }
+  if (storage.session.getUsername())
+    existingData.username = storage.session.getUsername();
+  if (storage.session.getPassword())
+    existingData.encodedPassword = await dataProtection.encrypt(
+      storage.session.getPassword()
+    ); // Buffer.from(storage.session.getPassword()).toString('base64');
+  if (storage.session.getLogApiKey())
+    existingData.logApiKey = storage.session.getLogApiKey();
+  if (storage.session.getLogApiSecret())
+    existingData.logApiSecret = storage.session.getLogApiSecret();
+  connectionsData[storage.session.getTenant()] = existingData;
+
+  fs.writeFileSync(filename, JSON.stringify(connectionsData, null, 2));
+}
+
+/**
+ * Delete connection profile
+ * @param {String} host host tenant host url or unique substring
+ */
+export function deleteConnectionProfile(host) {
+  const filename = getConnectionProfilesFileName();
+  let connectionsData = {};
+  fs.stat(filename, (err) => {
+    if (err == null) {
+      const data = fs.readFileSync(filename, 'utf8');
+      connectionsData = JSON.parse(data);
+      const profile = findConnectionProfile(connectionsData, host);
+      if (profile) {
+        printMessage(`Deleting connection profile ${profile.tenant}`);
+        delete connectionsData[profile.tenant];
+        fs.writeFileSync(filename, JSON.stringify(connectionsData, null, 2));
+      } else {
+        printMessage(`No connection profile ${host} found`);
+      }
+    } else if (err.code === 'ENOENT') {
+      printMessage(`Connection profile file ${filename} not found`);
+    } else {
+      printMessage(
+        `Error in deleting connection profile: ${err.code}`,
+        'error'
+      );
+    }
+  });
+}
+
+export async function describeConnectionProfile(host, showSecrets) {
+  const profile = await getConnectionProfileByHost(host);
+  if (profile) {
+    if (!showSecrets) {
+      delete profile.password;
+      delete profile.secret;
+    }
+    if (!profile.key) {
+      delete profile.key;
+      delete profile.secret;
+    }
+    const keyMap = {
+      tenant: 'Host',
+      username: 'Username',
+      password: 'Password',
+      key: 'Log API Key',
+      secret: 'Log API Secret',
+    };
+    const table = createObjectTable(profile, keyMap);
+    printMessage(table.toString(), 'data');
+  } else {
+    printMessage(`No connection profile ${host} found`);
+  }
+}

package/src/ops/EmailTemplateOps.js

@@ -0,0 +1,326 @@
+import fs from 'fs';
+import {
+  EMAIL_TEMPLATE_TYPE,
+  getEmailTemplate,
+  getEmailTemplates,
+  putEmailTemplate,
+} from '../api/EmailTemplateApi.js';
+import {
+  createProgressBar,
+  createTable,
+  printMessage,
+  stopProgressBar,
+  updateProgressBar,
+} from './utils/Console.js';
+import {
+  getTypedFilename,
+  saveJsonToFile,
+  validateImport,
+} from './utils/ExportImportUtils.js';
+import wordwrap from './utils/Wordwrap.js';
+
+/**
+ * Maintain the file type centrally
+ */
+const EMAIL_TEMPLATE_FILE_TYPE = 'template.email';
+
+// use a function vs a template variable to avoid problems in loops
+function getFileDataTemplate() {
+  return {
+    meta: {},
+    emailTemplate: {},
+  };
+}
+
+/**
+ * List email templates
+ * @param {boolean} long Long list format with details
+ */
+export async function listEmailTemplates(long = false) {
+  let emailTemplates = [];
+  try {
+    emailTemplates = (await getEmailTemplates()).data.result;
+  } catch (error) {
+    printMessage(`${error.message}`, 'error');
+    printMessage(error.response.data, 'error');
+  }
+  emailTemplates.sort((a, b) => a._id.localeCompare(b._id));
+  if (!long) {
+    for (const [, emailTemplate] of emailTemplates.entries()) {
+      printMessage(
+        `${emailTemplate._id.replace(`${EMAIL_TEMPLATE_TYPE}/`, '')}`,
+        'data'
+      );
+    }
+  } else {
+    const table = createTable([
+      'Id'.brightCyan,
+      'Name'.brightCyan,
+      'Status'.brightCyan,
+      'Locale(s)'.brightCyan,
+      'From'.brightCyan,
+      'Subject'.brightCyan,
+    ]);
+    emailTemplates.forEach((emailTemplate) => {
+      table.push([
+        // Id
+        `${emailTemplate._id.replace(`${EMAIL_TEMPLATE_TYPE}/`, '')}`,
+        // Name
+        `${emailTemplate.displayName ? emailTemplate.displayName : ''}`,
+        // Status
+        emailTemplate.enabled === false
+          ? 'disabled'.brightRed
+          : 'enabled'.brightGreen,
+        // Locale(s)
+        `${emailTemplate.defaultLocale}${
+          Object.keys(emailTemplate.subject).length > 1
+            ? ` (${Object.keys(emailTemplate.subject)
+                .filter((locale) => locale !== emailTemplate.defaultLocale)
+                .join(',')})`
+            : ''
+        }`,
+        // From
+        `${emailTemplate.from ? emailTemplate.from : ''}`,
+        // Subject
+        wordwrap(emailTemplate.subject[emailTemplate.defaultLocale], 40),
+      ]);
+    });
+    printMessage(table.toString(), 'data');
+  }
+}
+
+/**
+ * Export a single email template to file
+ * @param {String} templateId email template id
+ * @param {String} file optional filename
+ */
+export async function exportEmailTemplateToFile(templateId, file) {
+  let fileName = file;
+  if (!fileName) {
+    fileName = getTypedFilename(templateId, EMAIL_TEMPLATE_FILE_TYPE);
+  }
+  createProgressBar(1, `Exporting ${templateId}`);
+  getEmailTemplate(templateId)
+    .then(async (response) => {
+      const templateData = response.data;
+      updateProgressBar(`Writing file ${fileName}`);
+      const fileData = getFileDataTemplate();
+      fileData.emailTemplate[templateId] = templateData;
+      saveJsonToFile(fileData, fileName);
+      stopProgressBar(
+        `Exported ${templateId.brightCyan} to ${fileName.brightCyan}.`
+      );
+    })
+    .catch((err) => {
+      stopProgressBar(`${err}`);
+      printMessage(err, 'error');
+    });
+}
+
+/**
+ * Export all email templates to file
+ * @param {String} file optional filename
+ */
+export async function exportEmailTemplatesToFile(file) {
+  let fileName = file;
+  if (!fileName) {
+    fileName = getTypedFilename(`allEmailTemplates`, EMAIL_TEMPLATE_FILE_TYPE);
+  }
+  const fileData = getFileDataTemplate();
+  getEmailTemplates()
+    .then((response) => {
+      const templates = response.data.result;
+      createProgressBar(response.data.resultCount, 'Exporting email templates');
+      for (const template of templates) {
+        const templateId = template._id.replace(`${EMAIL_TEMPLATE_TYPE}/`, '');
+        updateProgressBar(`Exporting ${templateId}`);
+        fileData.emailTemplate[templateId] = template;
+      }
+      saveJsonToFile(fileData, fileName);
+      stopProgressBar(
+        `${response.data.resultCount} templates exported to ${fileName}.`
+      );
+    })
+    .catch((err) => {
+      stopProgressBar(`${err}`);
+      printMessage(err, 'error');
+    });
+}
+
+/**
+ * Export all email templates to separate files
+ */
+export async function exportEmailTemplatesToFiles() {
+  getEmailTemplates()
+    .then((response) => {
+      const templates = response.data.result;
+      createProgressBar(response.data.resultCount, 'Exporting email templates');
+      for (const template of templates) {
+        const templateId = template._id.replace(`${EMAIL_TEMPLATE_TYPE}/`, '');
+        const fileName = getTypedFilename(templateId, EMAIL_TEMPLATE_FILE_TYPE);
+        const fileData = getFileDataTemplate();
+        updateProgressBar(`Exporting ${templateId}`);
+        fileData.emailTemplate[templateId] = template;
+        saveJsonToFile(fileData, fileName);
+      }
+      stopProgressBar(`${response.data.resultCount} templates exported.`);
+    })
+    .catch((err) => {
+      stopProgressBar(`${err}`);
+      printMessage(err, 'error');
+    });
+}
+
+/**
+ * Import email template by id from file
+ * @param {String} templateId email template id
+ * @param {String} file optional filename
+ */
+export async function importEmailTemplateFromFile(templateId, file) {
+  // eslint-disable-next-line no-param-reassign
+  templateId = templateId.replaceAll(`${EMAIL_TEMPLATE_TYPE}/`, '');
+  fs.readFile(file, 'utf8', (err, data) => {
+    if (err) throw err;
+    const fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      createProgressBar(1, `Importing ${templateId}`);
+      if (fileData.emailTemplate[templateId]) {
+        putEmailTemplate(templateId, fileData.emailTemplate[templateId])
+          .then(() => {
+            updateProgressBar(`Importing ${templateId}`);
+            stopProgressBar(`Imported ${templateId}`);
+          })
+          .catch((putEmailTemplateError) => {
+            stopProgressBar(`${putEmailTemplateError}`);
+            printMessage(putEmailTemplateError, 'error');
+          });
+      } else {
+        stopProgressBar(
+          `Email template ${templateId.brightCyan} not found in ${file.brightCyan}!`
+        );
+        printMessage(
+          `Email template ${templateId.brightCyan} not found in ${file.brightCyan}!`,
+          'error'
+        );
+      }
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}
+
+/**
+ * Import all email templates from file
+ * @param {String} file optional filename
+ */
+export async function importEmailTemplatesFromFile(file) {
+  fs.readFile(file, 'utf8', async (err, data) => {
+    if (err) throw err;
+    const fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      createProgressBar(
+        Object.keys(fileData.emailTemplate).length,
+        `Importing email templates`
+      );
+      for (const id in fileData.emailTemplate) {
+        if ({}.hasOwnProperty.call(fileData.emailTemplate, id)) {
+          const templateId = id.replaceAll(`${EMAIL_TEMPLATE_TYPE}/`, '');
+          try {
+            // eslint-disable-next-line no-await-in-loop
+            await putEmailTemplate(
+              templateId,
+              fileData.emailTemplate[templateId]
+            );
+            updateProgressBar(`Imported ${templateId}`);
+          } catch (putEmailTemplateError) {
+            printMessage(`\nError importing ${templateId}`, 'error');
+            printMessage(putEmailTemplateError.response.data, 'error');
+          }
+        }
+      }
+      stopProgressBar(`Done.`);
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}
+
+/**
+ * Import all email templates from separate files
+ */
+export async function importEmailTemplatesFromFiles() {
+  const names = fs.readdirSync('.');
+  const jsonFiles = names.filter((name) =>
+    name.toLowerCase().endsWith(`${EMAIL_TEMPLATE_FILE_TYPE}.json`)
+  );
+  createProgressBar(jsonFiles.length, 'Importing email templates...');
+  let total = 0;
+  let totalErrors = 0;
+  for (const file of jsonFiles) {
+    const data = fs.readFileSync(file, 'utf8');
+    const fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      total += Object.keys(fileData.emailTemplate).length;
+      let errors = 0;
+      for (const id in fileData.emailTemplate) {
+        if ({}.hasOwnProperty.call(fileData.emailTemplate, id)) {
+          const templateId = id.replaceAll(`${EMAIL_TEMPLATE_TYPE}/`, '');
+          try {
+            // eslint-disable-next-line no-await-in-loop
+            await putEmailTemplate(
+              templateId,
+              fileData.emailTemplate[templateId]
+            );
+          } catch (putEmailTemplateError) {
+            errors += 1;
+            printMessage(`\nError importing ${templateId}`, 'error');
+            printMessage(putEmailTemplateError.response.data, 'error');
+          }
+        }
+      }
+      totalErrors += errors;
+      updateProgressBar(`Imported ${file}`);
+    } else {
+      printMessage(`Validation of ${file} failed!`, 'error');
+    }
+  }
+  stopProgressBar(
+    `Imported ${total - totalErrors} of ${total} email template(s) from ${
+      jsonFiles.length
+    } file(s).`
+  );
+}
+
+/**
+ * Import first email template from file
+ * @param {String} file optional filename
+ */
+export async function importFirstEmailTemplateFromFile(file) {
+  fs.readFile(file, 'utf8', (err, data) => {
+    if (err) throw err;
+    const fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      createProgressBar(1, `Importing first email template`);
+      for (const id in fileData.emailTemplate) {
+        if ({}.hasOwnProperty.call(fileData.emailTemplate, id)) {
+          putEmailTemplate(
+            id.replaceAll('emailTemplate/', ''),
+            fileData.emailTemplate[id]
+          )
+            .then(() => {
+              updateProgressBar(`Imported ${id}`);
+              stopProgressBar(`Imported ${id}`);
+            })
+            .catch((putEmailTemplateError) => {
+              stopProgressBar(`Error importing email template ${id}`);
+              printMessage(`\nError importing email template ${id}`, 'error');
+              printMessage(putEmailTemplateError.response.data, 'error');
+            });
+          break;
+        }
+      }
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}