@itentialopensource/adapter-efficientip_solidserver 0.1.1 → 0.3.0

package/utils/adapterInfo.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+/* @copyright Itential, LLC 2019 */
+/* eslint global-require:warn */
+/* eslint import/no-dynamic-require:warn */
+/* eslint prefer-destructuring:warn */
+
+const path = require('path');
+const fs = require('fs-extra');
+
+/**
+ * This script will determine the information about the adapter and store
+ * it into a file in the adapter.
+ */
+
+/**
+ * get adapter information
+ */
+function adapterInfo() {
+  // set the base pase of the adapter - tool shoud be one level up in utils
+  let adaptdir = __dirname;
+  const infoRes = {};
+
+  if (adaptdir.endsWith('/utils')) {
+    adaptdir = adaptdir.substring(0, adaptdir.length - 6);
+  }
+  const pack = require(`${adaptdir}/package.json`);
+  infoRes.version = pack.version;
+
+  let configCount = 0;
+  if (fs.existsSync(`${adaptdir}/pronghorn.json`)) {
+    const cFile = fs.readFileSync(`${adaptdir}/pronghorn.json`, 'utf8');
+    configCount += cFile.split('\n').length;
+  } else {
+    console.log('Missing - pronghorn.json');
+  }
+  if (fs.existsSync(`${adaptdir}/propertiesSchema.json`)) {
+    const cFile = fs.readFileSync(`${adaptdir}/propertiesSchema.json`, 'utf8');
+    configCount += cFile.split('\n').length;
+  } else {
+    console.log('Missing - propertiesSchema.json');
+  }
+  if (fs.existsSync(`${adaptdir}/error.json`)) {
+    const cFile = fs.readFileSync(`${adaptdir}/error.json`, 'utf8');
+    configCount += cFile.split('\n').length;
+  } else {
+    console.log('Missing - error.json');
+  }
+  const entitydir = path.join(adaptdir, '/entities');
+  if (fs.existsSync(entitydir) && fs.statSync(entitydir).isDirectory()) {
+    const entities = fs.readdirSync(entitydir);
+    // need to go through each entity in the entities directory
+    for (let e = 0; e < entities.length; e += 1) {
+      if (fs.statSync(`${entitydir}/${entities[e]}`).isDirectory()) {
+        const cfiles = fs.readdirSync(entitydir);
+        for (let c = 0; c < cfiles.length; c += 1) {
+          if (cfiles[c].endsWith('.json')) {
+            const ccFile = fs.readFileSync(`${entitydir}/${entities[e]}/${cfiles[c]}`, 'utf8');
+            configCount += ccFile.split('\n').length;
+          }
+        }
+      }
+    }
+  } else {
+    console.log('Could not find the entities directory');
+  }
+  infoRes.configLines = configCount;
+
+  let scodeCount = 0;
+  if (fs.existsSync(`${adaptdir}/utils/artifactize.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/artifactize.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/artifactize.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/basicGet.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/basicGet.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/basicGet.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/checkMigrate.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/checkMigrate.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/checkMigrate.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/findPath.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/findPath.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/findPath.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/modify.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/modify.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/modify.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/packModificationScript.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/packModificationScript.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/packModificationScript.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/setup.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/setup.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/setup.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/tbScript.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/tbScript.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/tbScript.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/tbUtils.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/tbUtils.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/tbUtils.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/testRunner.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/testRunner.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/testRunner.js');
+  }
+  if (fs.existsSync(`${adaptdir}/utils/troubleshootingAdapter.js`)) {
+    const sFile = fs.readFileSync(`${adaptdir}/utils/troubleshootingAdapter.js`, 'utf8');
+    scodeCount += sFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/troubleshootingAdapter.js');
+  }
+  infoRes.scriptLines = scodeCount;
+
+  let codeCount = 0;
+  if (fs.existsSync(`${adaptdir}/adapter.js`)) {
+    const aFile = fs.readFileSync(`${adaptdir}/adapter.js`, 'utf8');
+    codeCount += aFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/adapter.js');
+  }
+  if (fs.existsSync(`${adaptdir}/adapterBase.js`)) {
+    const aFile = fs.readFileSync(`${adaptdir}/adapterBase.js`, 'utf8');
+    codeCount += aFile.split('\n').length;
+  } else {
+    console.log('Missing - utils/adapterBase.js');
+  }
+  infoRes.codeLines = codeCount;
+
+  let tcodeCount = 0;
+  let ttestCount = 0;
+  if (fs.existsSync(`${adaptdir}/test/integration/adapterTestBasicGet.js`)) {
+    const tFile = fs.readFileSync(`${adaptdir}/test/integration/adapterTestBasicGet.js`, 'utf8');
+    tcodeCount += tFile.split('\n').length;
+    ttestCount += tFile.split('it(\'').length;
+  } else {
+    console.log('Missing - test/integration/adapterTestBasicGet.js');
+  }
+  if (fs.existsSync(`${adaptdir}/test/integration/adapterTestConnectivity.js`)) {
+    const tFile = fs.readFileSync(`${adaptdir}/test/integration/adapterTestConnectivity.js`, 'utf8');
+    tcodeCount += tFile.split('\n').length;
+    ttestCount += tFile.split('it(\'').length;
+  } else {
+    console.log('Missing - test/integration/adapterTestConnectivity.js');
+  }
+  if (fs.existsSync(`${adaptdir}/test/integration/adapterTestIntegration.js`)) {
+    const tFile = fs.readFileSync(`${adaptdir}/test/integration/adapterTestIntegration.js`, 'utf8');
+    tcodeCount += tFile.split('\n').length;
+    ttestCount += tFile.split('it(\'').length;
+  } else {
+    console.log('Missing - test/integration/adapterTestIntegration.js');
+  }
+  if (fs.existsSync(`${adaptdir}/test/unit/adapterBaseTestUnit.js`)) {
+    const tFile = fs.readFileSync(`${adaptdir}/test/unit/adapterBaseTestUnit.js`, 'utf8');
+    tcodeCount += tFile.split('\n').length;
+    ttestCount += tFile.split('it(\'').length;
+  } else {
+    console.log('Missing - test/unit/adapterBaseTestUnit.js');
+  }
+  if (fs.existsSync(`${adaptdir}/test/unit/adapterTestUnit.js`)) {
+    const tFile = fs.readFileSync(`${adaptdir}/test/unit/adapterTestUnit.js`, 'utf8');
+    tcodeCount += tFile.split('\n').length;
+    ttestCount += tFile.split('it(\'').length;
+  } else {
+    console.log('Missing - test/unit/adapterTestUnit.js');
+  }
+  infoRes.testLines = tcodeCount;
+  infoRes.testCases = ttestCount;
+  infoRes.totalCodeLines = scodeCount + codeCount + tcodeCount;
+
+  if (fs.existsSync(`${adaptdir}/pronghorn.json`)) {
+    // Read the entity schema from the file system
+    const phFile = path.join(adaptdir, '/pronghorn.json');
+    const prong = require(phFile);
+    infoRes.wfTasks = prong.methods.length;
+  } else {
+    console.log('Missing - pronghorn.json');
+  }
+
+  console.log(JSON.stringify(infoRes));
+  fs.writeFileSync(`${adaptdir}/report/adapterInfo.json`, JSON.stringify(infoRes, null, 2));
+}
+
+adapterInfo();

package/utils/addAuth.js

@@ -0,0 +1,94 @@
+/* eslint-disable no-plusplus */
+/* eslint global-require: warn */
+/* eslint import/no-dynamic-require: warn */
+
+const path = require('path');
+const fs = require('fs');
+const rls = require('readline-sync');
+
+function getQuestions(props, obj) {
+  const questions = props.map((p) => `${p}: ${(obj[p] !== undefined) ? `(${obj[p]})` : ''} `);
+  return questions;
+}
+
+// function outputs each property for user to edit/confirm
+// props are the fields that need to be changed depending on what the user selects
+// obj is the JSON object that's being updated
+function confirm(props, obj) {
+  // create array of questions
+  const updatedObj = obj;
+  getQuestions(props, obj).forEach((q) => {
+    const answer = rls.question(q);
+    // only update the field if the answer is NOT and empty string
+    if (answer) {
+      updatedObj[q.split(':')[0].trim()] = answer;
+    }
+  });
+  return updatedObj;
+}
+
+const updateBasicAuth = (auth) => {
+  const propsToUpdate = ['username', 'password', 'auth_field', 'auth_field_format'];
+  return confirm(propsToUpdate, auth);
+};
+
+const updateStaticTokenAuth = (auth) => {
+  const propsToUpdate = ['token', 'auth_field', 'auth_field_format'];
+  return confirm(propsToUpdate, auth);
+};
+
+function updateTokenSchemas(user, pw, token) {
+  let schemaPath = path.join(__dirname, '..', 'entities/.system/schemaTokenReq.json');
+  const reqSchema = require(schemaPath);
+  reqSchema.properties.username.external_name = user;
+  reqSchema.properties.password.external_name = pw;
+  fs.writeFileSync(schemaPath, JSON.stringify(reqSchema, null, 2));
+  schemaPath = path.join(__dirname, '..', 'entities/.system/schemaTokenResp.json');
+  const respSchema = require(schemaPath);
+  respSchema.properties.token.external_name = token;
+  fs.writeFileSync(schemaPath, JSON.stringify(respSchema, null, 2));
+}
+
+function updateRequestToken(auth) {
+  const propsToUpdate = [
+    'username',
+    'password',
+    'auth_field',
+    'auth_field_format',
+    'token_user_field',
+    'token_password_field',
+    'token_result_field',
+    'token_URI_path'
+  ];
+  const newAuth = confirm(propsToUpdate, auth);
+  updateTokenSchemas(newAuth.token_user_field, newAuth.token_password_field, newAuth.token_result_field);
+
+  return newAuth;
+}
+
+// prompt users to pick an auth method from the list above
+const addAuthInfo = (props) => {
+  const authOptions = [
+    'basic user_password',
+    'static_token',
+    'request_token',
+    'no_authentication'
+  ];
+  const newProps = confirm(['host', 'port', 'base_path'], props);
+
+  const newAuthMethod = authOptions[rls.keyInSelect(authOptions, 'Which authentication method?')];
+  newProps.authentication.auth_method = newAuthMethod;
+
+  if (newAuthMethod === 'basic user_password') {
+    newProps.authentication = updateBasicAuth(newProps.authentication);
+  } else if (newAuthMethod === 'static_token') {
+    newProps.authentication = updateStaticTokenAuth(newProps.authentication);
+  } else if (newAuthMethod === 'request_token') {
+    newProps.authentication = updateRequestToken(newProps.authentication);
+  }
+  console.log('Connectivity and authentication properties have been configured');
+  console.log('If you want to make changes, rerun this script to reinstall the adapter');
+  return newProps;
+};
+
+module.exports = { addAuthInfo };

package/utils/artifactize.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 /* @copyright Itential, LLC 2019 */
 
-const fs = require('fs-extra');
 const path = require('path');
+const fs = require('fs-extra');
 
 async function createBundle(adapterOldDir) {
   // set directories

package/utils/basicGet.js

@@ -4,6 +4,7 @@
 /* eslint import/no-extraneous-dependencies: warn */
 /* eslint global-require: warn */
 /* eslint import/no-unresolved: warn */
+/* eslint import/no-dynamic-require: warn */
 
 const winston = require('winston');
 
@@ -43,20 +44,6 @@ const basicGet = {
       adapter.id,
       adapterProps
     );
-  },
-
-  /**
-   * @summary connect to mongodb
-   *
-   * @function connect
-   * @param {Object} properties - pronghornProps
-   */
-  connect: async function connect(properties) {
-    // Connect to Mongo
-    const { MongoDBConnection } = require('@itential/database');
-    const connection = new MongoDBConnection(properties.mongoProps);
-    const database = await connection.connect(true);
-    return database;
   }
 };
 

package/utils/checkMigrate.js

@@ -1,7 +1,7 @@
 const { execSync } = require('child_process');
+const fs = require('fs');
 const semver = require('semver');
 const axios = require('axios');
-const fs = require('fs');
 const packageJson = require('../package.json');
 
 const localEngineVer = packageJson.engineVersion;

package/utils/entitiesToDB.js

@@ -0,0 +1,179 @@
+/* @copyright Itential, LLC 2021 */
+
+// Set globals
+/* global log */
+
+/* eslint import/no-dynamic-require: warn */
+/* eslint global-require: warn */
+/* eslint no-unused-vars: warn */
+/* eslint import/no-unresolved: warn */
+/* eslint no-promise-executor-return: warn */
+
+/**
+ *  This script is used to read through an adapter's entities files
+ *  and then creates documents and enters them into the IAP mongodb
+ */
+
+const fs = require('fs');
+const path = require('path');
+const utils = require('./tbUtils');
+
+// get the pronghorn database information
+const getPronghornProps = async (iapDir) => {
+  log.trace('Retrieving properties.json file...');
+  const rawProps = require(path.join(iapDir, 'properties.json'));
+  log.trace('Decrypting properties...');
+  const { PropertyEncryption } = require('@itential/itential-utils');
+  const propertyEncryption = new PropertyEncryption();
+  const pronghornProps = await propertyEncryption.decryptProps(rawProps);
+  log.trace('Found properties.\n');
+  return pronghornProps;
+};
+
+/**
+ *  Function used to take a file path to a entity directory and build
+ *  a document that corresponds to the entity files.
+ */
+const buildDoc = (pathstring) => {
+  let files = fs.readdirSync(pathstring);
+
+  // load the mockdatafiles
+  const mockdatafiles = {};
+  if (files.includes('mockdatafiles') && fs.lstatSync(`${pathstring}/mockdatafiles`).isDirectory()) {
+    fs.readdirSync(`${pathstring}/mockdatafiles`).forEach((file) => {
+      if (file.split('.').pop() === 'json') {
+        const mockpath = `${pathstring}/mockdatafiles/${file}`;
+        const data = JSON.parse(fs.readFileSync(mockpath));
+        mockdatafiles[mockpath.split('/').pop()] = data;
+      }
+    });
+  }
+
+  // load the action data
+  let actions;
+  if (files.includes('action.json')) {
+    actions = JSON.parse(fs.readFileSync(`${pathstring}/action.json`));
+  }
+
+  // Load schema.json and other schemas in remaining json files
+  files = files.filter((f) => (f !== 'action.json') && f.endsWith('.json'));
+  const schema = [];
+  files.forEach((file) => {
+    const data = JSON.parse(fs.readFileSync(`${pathstring}/${file}`));
+    schema.push({
+      name: file,
+      schema: data
+    });
+  });
+
+  // return the data
+  return {
+    actions: actions.actions,
+    schema,
+    mockdatafiles
+  };
+};
+
+/**
+ *  Function used to get the database from the options or a provided directory
+ */
+const optionsHandler = (options) => {
+  // if the database properties were provided in the options - return them
+  if (options.pronghornProps) {
+    if (typeof options.pronghornProps === 'string') {
+      return JSON.parse(options.pronghornProps);
+    }
+    return new Promise((resolve, reject) => resolve(options.pronghornProps));
+  }
+
+  // if the directory was provided, get the pronghorn props from the directory
+  if (options.iapDir) {
+    return getPronghornProps(options.iapDir);
+  }
+
+  // if nothing was provided, error
+  return new Promise((resolve, reject) => reject(new Error('Neither pronghornProps nor iapDir defined in options!')));
+};
+
+/**
+ *  Function used to put the adapter configuration into the provided database
+ */
+const moveEntitiesToDB = async (targetPath, options) => {
+  // set local variables
+  let myOpts = options;
+  let myPath = targetPath;
+
+  // if we got a string parse into a JSON object
+  if (typeof myOpts === 'string') {
+    myOpts = JSON.parse(myOpts);
+  }
+
+  // if there is no target collection - set the collection to the default
+  if (!myOpts.targetCollection) {
+    myOpts.targetCollection = 'adapter_configs';
+  }
+
+  // if there is no id error since we need an id for the entities
+  if (!myOpts.id) {
+    throw new Error('Adapter ID required!');
+  }
+
+  // get the pronghorn database properties
+  return optionsHandler(options).then(async (currentProps) => {
+    // Check valid filepath provided
+    if (!myPath) {
+      // if no path use the current directory without the utils
+      myPath = path.join(__dirname, '../');
+    } else if (myPath.slice(-1) === '/') {
+      myPath = myPath.slice(0, -1);
+    }
+
+    // verify set the entity path
+    const entitiesPath = `${myPath}/entities`;
+    if (!fs.existsSync(entitiesPath)) {
+      throw new Error(`Entities path does not exist in filesystem: ${entitiesPath}`);
+    } else {
+      log.trace('Target found on filesystem');
+    }
+
+    // Get adapter details
+    if (!fs.existsSync(`${myPath}/pronghorn.json`)) {
+      throw new Error(`pronghorn.json does not exist in path: ${myPath}`);
+    } else {
+      log.trace('pronghorn.json found on filesystem');
+    }
+    const adapterData = JSON.parse(fs.readFileSync(`${myPath}/pronghorn.json`));
+
+    // Load files from the filesystem
+    const docs = [];
+    const entities = fs.readdirSync(entitiesPath);
+    entities.forEach((entity) => {
+      const entityPath = `${entitiesPath}/${entity}`;
+      const isDir = fs.lstatSync(entitiesPath).isDirectory();
+
+      // Build doc for entity
+      if (isDir) {
+        let doc = buildDoc(entityPath);
+        doc = {
+          id: myOpts.id,
+          type: adapterData.id,
+          entity,
+          ...doc
+        };
+        docs.push(doc);
+      }
+    });
+
+    // Upload documents to db collection
+    const db = await utils.connect(currentProps).catch((err) => { console.error(err); throw err; });
+    if (!db) {
+      console.error('Error occured when connectiong to database', currentProps);
+      throw new Error('Database not found');
+    }
+    const collection = db.collection(myOpts.targetCollection);
+    const res = await collection.insertMany(docs, { checkKeys: false }).catch((err) => { console.error(err); throw err; });
+    return res;
+  });
+};
+
+module.exports = { moveEntitiesToDB };

package/utils/findPath.js

@@ -4,8 +4,8 @@
 /* eslint import/no-dynamic-require:warn */
 /* eslint prefer-destructuring:warn */
 
-const fs = require('fs-extra');
 const path = require('path');
+const fs = require('fs-extra');
 const rls = require('readline-sync');
 
 /**