@rockcarver/frodo-lib 0.11.0

package/src/ops/ThemeOps.js

@@ -0,0 +1,379 @@
+import fs from 'fs';
+import {
+  deleteTheme,
+  deleteThemeByName,
+  deleteThemes,
+  getTheme,
+  getThemeByName,
+  getThemes,
+  putTheme,
+  putThemeByName,
+  putThemes,
+} from '../api/ThemeApi.js';
+import {
+  createProgressBar,
+  createTable,
+  failSpinner,
+  printMessage,
+  showSpinner,
+  stopProgressBar,
+  succeedSpinner,
+  updateProgressBar,
+} from './utils/Console.js';
+import {
+  getRealmString,
+  getTypedFilename,
+  saveToFile,
+  validateImport,
+} from './utils/ExportImportUtils.js';
+
+/**
+ * List all the themes
+ * @param {boolean} long Long version, more fields
+ */
+export async function listThemes(long = false) {
+  const themeList = await getThemes();
+  themeList.sort((a, b) => a.name.localeCompare(b.name));
+  if (!long) {
+    themeList.forEach((theme) => {
+      printMessage(
+        `${theme.isDefault ? theme.name.brightCyan : theme.name}`,
+        'data'
+      );
+    });
+  } else {
+    const table = createTable([
+      'Name'.brightCyan,
+      'Id'.brightCyan,
+      'Default'.brightCyan,
+    ]);
+    themeList.forEach((theme) => {
+      table.push([
+        `${theme.name}`,
+        `${theme._id}`,
+        `${theme.isDefault ? 'Yes'.brightGreen : ''}`,
+      ]);
+    });
+    printMessage(table.toString(), 'data');
+  }
+}
+
+/**
+ * Export theme by name to file
+ * @param {String} name theme name
+ * @param {String} file optional export file name
+ */
+export async function exportThemeByName(name, file) {
+  let fileName = getTypedFilename(name, 'theme');
+  if (file) {
+    fileName = file;
+  }
+  createProgressBar(1, `Exporting ${name}`);
+  const themeData = await getThemeByName(name);
+  if (themeData.length === 0) {
+    stopProgressBar(`Theme ${name} not found!`);
+    printMessage(`Theme ${name} not found!`, 'error');
+  } else {
+    updateProgressBar(`Writing file ${fileName}`);
+    saveToFile('theme', themeData, '_id', fileName);
+    stopProgressBar(`Successfully exported theme ${name}.`);
+  }
+}
+
+/**
+ * Export theme by uuid to file
+ * @param {String} id theme uuid
+ * @param {String} file optional export file name
+ */
+export async function exportThemeById(id, file) {
+  let fileName = getTypedFilename(id, 'theme');
+  if (file) {
+    fileName = file;
+  }
+  createProgressBar(1, `Exporting ${id}`);
+  const themeData = await getTheme(id);
+  if (themeData.length === 0) {
+    stopProgressBar(`Theme ${id} not found!`);
+    printMessage(`Theme ${id} not found!`, 'error');
+  } else {
+    updateProgressBar(`Writing file ${fileName}`);
+    saveToFile('theme', themeData, '_id', fileName);
+    stopProgressBar(`Successfully exported theme ${id}.`);
+  }
+}
+
+/**
+ * Export all themes to file
+ * @param {String} file optional export file name
+ */
+export async function exportThemesToFile(file) {
+  let fileName = getTypedFilename(`all${getRealmString()}Themes`, 'theme');
+  if (file) {
+    fileName = file;
+  }
+  const allThemesData = await getThemes();
+  createProgressBar(allThemesData.length, 'Exporting themes');
+  for (const themeData of allThemesData) {
+    updateProgressBar(`Exporting theme ${themeData.name}`);
+  }
+  saveToFile('theme', allThemesData, '_id', fileName);
+  stopProgressBar(`${allThemesData.length} themes exported to ${fileName}.`);
+}
+
+/**
+ * Export all themes to separate files
+ */
+export async function exportThemesToFiles() {
+  const allThemesData = await getThemes();
+  createProgressBar(allThemesData.length, 'Exporting themes');
+  for (const themeData of allThemesData) {
+    updateProgressBar(`Writing theme ${themeData.name}`);
+    const fileName = getTypedFilename(themeData.name, 'theme');
+    saveToFile('theme', themeData, '_id', fileName);
+  }
+  stopProgressBar(`${allThemesData.length} themes exported.`);
+}
+
+/**
+ * Import theme by name from file
+ * @param {String} name theme name
+ * @param {String} file import file name
+ */
+export async function importThemeByName(name, file) {
+  fs.readFile(file, 'utf8', (err, data) => {
+    if (err) throw err;
+    const themeData = JSON.parse(data);
+    if (validateImport(themeData.meta)) {
+      createProgressBar(1, 'Importing theme...');
+      let found = false;
+      for (const id in themeData.theme) {
+        if ({}.hasOwnProperty.call(themeData.theme, id)) {
+          if (themeData.theme[id].name === name) {
+            found = true;
+            updateProgressBar(`Importing ${themeData.theme[id].name}`);
+            putThemeByName(name, themeData.theme[id]).then((result) => {
+              if (result == null) {
+                stopProgressBar(
+                  `Error importing theme ${themeData.theme[id].name}`
+                );
+                printMessage(
+                  `Error importing theme ${themeData.theme[id].name}`,
+                  'error'
+                );
+              } else {
+                stopProgressBar(`Successfully imported theme ${name}.`);
+              }
+            });
+            break;
+          }
+        }
+      }
+      if (!found) {
+        stopProgressBar(`Theme ${name} not found!`);
+      }
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}
+
+/**
+ * Import theme by uuid from file
+ * @param {String} id theme uuid
+ * @param {String} file import file name
+ */
+export async function importThemeById(id, file) {
+  fs.readFile(file, 'utf8', (err, data) => {
+    if (err) throw err;
+    const themeData = JSON.parse(data);
+    if (validateImport(themeData.meta)) {
+      createProgressBar(1, 'Importing theme...');
+      let found = false;
+      for (const themeId in themeData.theme) {
+        if ({}.hasOwnProperty.call(themeData.theme, themeId)) {
+          if (themeId === id) {
+            found = true;
+            updateProgressBar(`Importing ${themeData.theme[themeId]._id}`);
+            putTheme(themeId, themeData.theme[themeId]).then((result) => {
+              if (result == null) {
+                stopProgressBar(
+                  `Error importing theme ${themeData.theme[themeId]._id}`
+                );
+                printMessage(
+                  `Error importing theme ${themeData.theme[themeId]._id}`,
+                  'error'
+                );
+              } else {
+                stopProgressBar(`Successfully imported theme ${id}.`);
+              }
+            });
+            break;
+          }
+        }
+      }
+      if (!found) {
+        stopProgressBar(`Theme ${id} not found!`);
+      }
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}
+
+/**
+ * Import all themes from single file
+ * @param {String} file import file name
+ */
+export async function importThemesFromFile(file) {
+  fs.readFile(file, 'utf8', (err, data) => {
+    if (err) throw err;
+    const fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      createProgressBar(
+        Object.keys(fileData.theme).length,
+        'Importing themes...'
+      );
+      for (const id in fileData.theme) {
+        if ({}.hasOwnProperty.call(fileData.theme, id)) {
+          updateProgressBar(`Importing ${fileData.theme[id].name}`);
+        }
+      }
+      putThemes(fileData.theme).then((result) => {
+        if (result == null) {
+          stopProgressBar(
+            `Error importing ${Object.keys(fileData.theme).length} themes!`
+          );
+          printMessage(
+            `Error importing ${
+              Object.keys(fileData.theme).length
+            } themes from ${file}`,
+            'error'
+          );
+        } else {
+          stopProgressBar(
+            `Successfully imported ${
+              Object.keys(fileData.theme).length
+            } themes.`
+          );
+        }
+      });
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}
+
+/**
+ * Import themes from separate files
+ */
+export async function importThemesFromFiles() {
+  const names = fs.readdirSync('.');
+  const jsonFiles = names.filter((name) =>
+    name.toLowerCase().endsWith('.theme.json')
+  );
+
+  createProgressBar(jsonFiles.length, 'Importing themes...');
+  let fileData = null;
+  let count = 0;
+  let total = 0;
+  let files = 0;
+  for (const file of jsonFiles) {
+    const data = fs.readFileSync(file, 'utf8');
+    fileData = JSON.parse(data);
+    if (validateImport(fileData.meta)) {
+      count = Object.keys(fileData.theme).length;
+      // eslint-disable-next-line no-await-in-loop
+      const result = await putThemes(fileData.theme);
+      if (result == null) {
+        printMessage(`Error importing ${count} themes from ${file}`, 'error');
+      } else {
+        files += 1;
+        total += count;
+        updateProgressBar(`Imported ${count} theme(s) from ${file}`);
+      }
+    } else {
+      printMessage(`Validation of ${file} failed!`, 'error');
+    }
+  }
+  stopProgressBar(
+    `Finished importing ${total} theme(s) from ${files} file(s).`
+  );
+}
+
+/**
+ * Import first theme from file
+ * @param {String} file import file name
+ */
+export async function importFirstThemeFromFile(file) {
+  fs.readFile(file, 'utf8', (err, data) => {
+    if (err) throw err;
+    const themeData = JSON.parse(data);
+    if (validateImport(themeData.meta)) {
+      createProgressBar(1, 'Importing theme...');
+      for (const id in themeData.theme) {
+        if ({}.hasOwnProperty.call(themeData.theme, id)) {
+          updateProgressBar(`Importing ${themeData.theme[id].name}`);
+          putTheme(id, themeData.theme[id]).then((result) => {
+            if (result == null) {
+              stopProgressBar(
+                `Error importing theme ${themeData.theme[id].name}`
+              );
+              printMessage(
+                `Error importing theme ${themeData.theme[id].name}`,
+                'error'
+              );
+            } else {
+              stopProgressBar(
+                `Successfully imported theme ${themeData.theme[id].name}`
+              );
+            }
+          });
+          break;
+        }
+      }
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}
+
+/**
+ * Delete theme by id
+ * @param {String} id theme id
+ */
+export async function deleteThemeCmd(id) {
+  showSpinner(`Deleting ${id}...`);
+  try {
+    await deleteTheme(id);
+    succeedSpinner(`Deleted ${id}.`);
+  } catch (error) {
+    failSpinner(`Error: ${error.message}`);
+  }
+}
+
+/**
+ * Delete theme by name
+ * @param {String} name theme name
+ */
+export async function deleteThemeByNameCmd(name) {
+  showSpinner(`Deleting ${name}...`);
+  try {
+    await deleteThemeByName(name);
+    succeedSpinner(`Deleted ${name}.`);
+  } catch (error) {
+    failSpinner(`Error: ${error.message}`);
+  }
+}
+
+/**
+ * Delete all themes
+ */
+export async function deleteThemesCmd() {
+  showSpinner(`Deleting all realm themes...`);
+  try {
+    await deleteThemes();
+    succeedSpinner(`Deleted all realm themes.`);
+  } catch (error) {
+    failSpinner(`Error: ${error.message}`);
+  }
+}

package/src/ops/VariablesOps.js

@@ -0,0 +1,185 @@
+import {
+  createKeyValueTable,
+  createProgressBar,
+  createTable,
+  failSpinner,
+  printMessage,
+  showSpinner,
+  stopProgressBar,
+  succeedSpinner,
+  updateProgressBar,
+} from './utils/Console.js';
+import {
+  deleteVariable,
+  getVariable,
+  getVariables,
+  putVariable,
+  setVariableDescription,
+} from '../api/VariablesApi.js';
+import wordwrap from './utils/Wordwrap.js';
+import { resolveUserName } from './ManagedObjectOps.js';
+import { decode } from '../api/utils/Base64.js';
+
+/**
+ * List variables
+ * @param {boolean} long Long version, all the fields
+ */
+export async function listVariables(long) {
+  let variables = [];
+  try {
+    variables = (await getVariables()).data.result;
+  } catch (error) {
+    printMessage(`${error.message}`, 'error');
+    printMessage(error.response.data, 'error');
+  }
+  if (long) {
+    const table = createTable([
+      'Id'.brightCyan,
+      'Value'.brightCyan,
+      'Status'.brightCyan,
+      'Description'.brightCyan,
+      'Modifier'.brightCyan,
+      'Modified'.brightCyan,
+    ]);
+    variables.sort((a, b) => a._id.localeCompare(b._id));
+    for (const variable of variables) {
+      table.push([
+        variable._id,
+        wordwrap(decode(variable.valueBase64), 40),
+        variable.loaded ? 'loaded'.brightGreen : 'unloaded'.brightRed,
+        wordwrap(variable.description, 40),
+        // eslint-disable-next-line no-await-in-loop
+        await resolveUserName('teammember', variable.lastChangedBy),
+        new Date(variable.lastChangeDate).toLocaleString(),
+      ]);
+    }
+    printMessage(table.toString());
+  } else {
+    variables.forEach((secret) => {
+      printMessage(secret._id);
+    });
+  }
+}
+
+/**
+ * Create variable
+ * @param {String} variableId variable id
+ * @param {String} value variable value
+ * @param {String} description variable description
+ */
+export async function createVariable(variableId, value, description) {
+  showSpinner(`Creating variable ${variableId}...`);
+  try {
+    await putVariable(variableId, value, description);
+    succeedSpinner(`Created variable ${variableId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Update variable
+ * @param {String} variableId variable id
+ * @param {String} value variable value
+ * @param {String} description variable description
+ */
+export async function updateVariable(variableId, value, description) {
+  showSpinner(`Updating variable ${variableId}...`);
+  try {
+    await putVariable(variableId, value, description);
+    succeedSpinner(`Updated variable ${variableId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Set description of variable
+ * @param {String} variableId variable id
+ * @param {String} description variable description
+ */
+export async function setDescriptionOfVariable(variableId, description) {
+  showSpinner(`Setting description of variable ${variableId}...`);
+  try {
+    await setVariableDescription(variableId, description);
+    succeedSpinner(`Set description of variable ${variableId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Delete a variable
+ * @param {String} variableId variable id
+ */
+export async function deleteVariableCmd(variableId) {
+  showSpinner(`Deleting variable ${variableId}...`);
+  try {
+    await deleteVariable(variableId);
+    succeedSpinner(`Deleted variable ${variableId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Delete all variables
+ */
+export async function deleteVariablesCmd() {
+  try {
+    const variables = (await getVariables()).data.result;
+    createProgressBar(variables.length, `Deleting variable...`);
+    for (const variable of variables) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await deleteVariable(variable._id);
+        updateProgressBar(`Deleted variable ${variable._id}`);
+      } catch (error) {
+        printMessage(
+          `Error: ${error.response.data.code} - ${error.response.data.message}`,
+          'error'
+        );
+      }
+    }
+    stopProgressBar(`Variables deleted.`);
+  } catch (error) {
+    printMessage(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`,
+      'error'
+    );
+  }
+}
+
+/**
+ * Describe a variable
+ * @param {String} variableId variable id
+ */
+export async function describeVariable(variableId) {
+  const variable = (await getVariable(variableId)).data;
+  const table = createKeyValueTable();
+  table.push(['Name'.brightCyan, variable._id]);
+  table.push(['Value'.brightCyan, wordwrap(decode(variable.valueBase64), 40)]);
+  table.push([
+    'Status'.brightCyan,
+    variable.loaded ? 'loaded'.brightGreen : 'unloaded'.brightRed,
+  ]);
+  table.push(['Description'.brightCyan, wordwrap(variable.description, 60)]);
+  table.push([
+    'Modified'.brightCyan,
+    new Date(variable.lastChangeDate).toLocaleString(),
+  ]);
+  table.push([
+    'Modifier'.brightCyan,
+    await resolveUserName('teammember', variable.lastChangedBy),
+  ]);
+  table.push(['Modifier UUID'.brightCyan, variable.lastChangedBy]);
+  printMessage(table.toString());
+}