@itentialopensource/adapter-netbox_v210 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,4 +1,12 @@
 
+## 0.1.2 [12-30-2021]
+
+* Add / to generic call paths
+
+See merge request itentialopensource/adapters/inventory/adapter-netbox_v210!1
+
+---
+
 ## 0.1.1 [08-02-2021]
 
 * Bug fixes and performance improvements
@@ -6,4 +14,3 @@
 See commit 1173452
 
 ---
-

package/adapterBase.js

@@ -22,6 +22,7 @@ const AjvCl = require('ajv');
 const PropUtilCl = require('@itentialopensource/adapter-utils').PropertyUtility;
 const RequestHandlerCl = require('@itentialopensource/adapter-utils').RequestHandler;
 
+const entitiesToDB = require(path.join(__dirname, 'utils/entitiesToDB'));
 const troubleshootingAdapter = require(path.join(__dirname, 'utils/troubleshootingAdapter'));
 const tbUtils = require(path.join(__dirname, 'utils/tbUtils'));
 
@@ -821,7 +822,7 @@ class AdapterBase extends EventEmitterCl {
    */
   async runConnectivity(callback) {
     try {
-      const { serviceItem } = await troubleshootingAdapter.getAdapterConfig();
+      const { serviceItem } = await tbUtils.getAdapterConfig();
       const { host } = serviceItem.properties.properties;
       const result = tbUtils.runConnectivity(host, false);
       if (result.failCount > 0) {
@@ -1001,6 +1002,27 @@ class AdapterBase extends EventEmitterCl {
       return [];
     }
   }
+
+  /**
+   * @summary moves entities to mongo database
+   *
+   * @function moveEntitiesToDB
+   *
+   * @return {Callback} - containing the response from the mongo transaction
+   */
+  moveEntitiesToDB(callback) {
+    const meth = 'adapterBase-moveEntitiesToDB';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return callback(entitiesToDB.moveEntitiesToDB(__dirname, { pronghornProps: this.allProps, id: this.id }), null);
+    } catch (err) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, err);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
 }
 
 module.exports = AdapterBase;

package/entities/.generic/action.json

@@ -4,7 +4,7 @@
       "name": "getGenerics",
       "protocol": "REST",
       "method": "GET",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -25,7 +25,7 @@
       "name": "createGeneric",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -46,7 +46,7 @@
       "name": "updateGeneric",
       "protocol": "REST",
       "method": "PUT",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -67,7 +67,7 @@
       "name": "patchGeneric",
       "protocol": "REST",
       "method": "PATCH",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -88,7 +88,7 @@
       "name": "deleteGeneric",
       "protocol": "REST",
       "method": "DELETE",
-      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}?{query}",
+      "entitypath": "{base_path}/{version}/{pathv1}/{pathv2}/{pathv3}/{pathv4}/{pathv5}/{pathv6}/{pathv7}/{pathv8}/{pathv9}/{pathv10}/{pathv11}/{pathv12}/{pathv13}/{pathv14}/{pathv15}/{pathv16}/{pathv17}/{pathv18}/{pathv19}/{pathv20}?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@itentialopensource/adapter-netbox_v210",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "This adapter integrates with system described as: Netbox v2.10",
   "main": "adapter.js",
-  "wizardVersion": "2.44.5",
-  "engineVersion": "1.59.28",
+  "wizardVersion": "2.44.7",
+  "engineVersion": "1.59.55",
   "adapterType": "http",
   "scripts": {
     "artifactize": "npm i && node utils/packModificationScript.js",
-    "preinstall": "node utils/setup.js",
+    "preinstall": "node utils/setup.js && npm install --package-lock-only --ignore-scripts && npx npm-force-resolutions",
     "lint": "node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js",
     "lint:errors": "node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js --quiet",
     "test:baseunit": "mocha test/unit/adapterBaseTestUnit.js --LOG=error",
@@ -16,7 +16,7 @@
     "test:integration": "mocha test/integration/adapterTestIntegration.js --LOG=error",
     "test:cover": "nyc --reporter html --reporter text mocha --reporter dot test/*",
     "test": "npm run test:baseunit && npm run test:unit && npm run test:integration",
-    "adapter:install": "node utils/tbScript.js install",
+    "adapter:install": "npm i && node utils/tbScript.js install",
     "adapter:checkMigrate": "node utils/checkMigrate.js",
     "adapter:findPath": "node utils/findPath.js",
     "adapter:migrate": "node utils/modify.js -m",
@@ -26,7 +26,7 @@
     "healthcheck": "node utils/tbScript.js healthcheck",
     "basicget": "node utils/tbScript.js basicget",
     "connectivity": "node utils/tbScript.js connectivity",
-    "deploy": "npm publish --registry=http://registry.npmjs.org --access=public",
+    "deploy": "npm publish --registry=https://registry.npmjs.org --access=public",
     "build": "npm run deploy"
   },
   "keywords": [
@@ -53,13 +53,14 @@
   "author": "Itential",
   "homepage": "https://gitlab.com/itentialopensource/adapters/inventory/adapter-netbox_v210#readme",
   "dependencies": {
-    "@itentialopensource/adapter-utils": "^4.44.0",
+    "@itentialopensource/adapter-utils": "^4.44.11",
     "ajv": "^6.12.0",
     "axios": "^0.21.0",
     "commander": "^2.20.0",
     "fs-extra": "^8.1.0",
     "mocha": "^9.0.1",
     "mocha-param": "^2.0.1",
+    "mongodb": "^4.1.0",
     "network-diagnostics": "^0.5.3",
     "nyc": "^15.1.0",
     "readline-sync": "^1.4.10",
@@ -75,5 +76,8 @@
     "package-json-validator": "^0.6.3",
     "testdouble": "^3.16.1"
   },
+  "resolutions": {
+    "minimist": "^1.2.5"
+  },
   "private": false
 }

package/propertiesSchema.json

@@ -837,4 +837,4 @@
       }
     }
   }
-}
+}

package/test/integration/adapterTestIntegration.js

@@ -14,7 +14,10 @@ const winston = require('winston');
 const { expect } = require('chai');
 const { use } = require('chai');
 const td = require('testdouble');
+const util = require('util');
+const pronghorn = require('../../pronghorn.json');
 
+pronghorn.methodsByName = pronghorn.methods.reduce((result, meth) => ({ ...result, [meth.name]: meth }), {});
 const anything = td.matchers.anything();
 
 // stub and attemptTimeout are used throughout the code so set them here

package/test/unit/adapterBaseTestUnit.js

@@ -317,7 +317,7 @@ describe('[unit] Adapter Base Test', () => {
       });
       it('should return a list of functions', (done) => {
         const returnedFunctions = ['addEntityCache', 'capabilityResults', 'checkActionFiles', 'checkProperties', 'connect', 'encryptProperty',
-          'entityInList', 'findPath', 'getAllCapabilities', 'getAllFunctions', 'getQueue', 'getWorkflowFunctions', 'healthCheck',
+          'entityInList', 'findPath', 'getAllCapabilities', 'getAllFunctions', 'getQueue', 'getWorkflowFunctions', 'healthCheck', 'moveEntitiesToDB',
           'refreshProperties', 'runBasicGet', 'runConnectivity', 'runHealthcheck', 'suspend', 'troubleshoot', 'unsuspend', 'updateAdapterConfiguration', 'addListener',
           'emit', 'eventNames', 'getMaxListeners', 'listenerCount', 'listeners', 'off', 'on', 'once', 'prependListener',
           'prependOnceListener', 'rawListeners', 'removeAllListeners', 'removeListener', 'setMaxListeners'];

package/test/unit/adapterTestUnit.js

@@ -356,6 +356,7 @@ describe('[unit] Netbox_v210 Adapter Test', () => {
           assert.notEqual(undefined, packageDotJson.scripts);
           assert.notEqual(null, packageDotJson.scripts);
           assert.notEqual('', packageDotJson.scripts);
+          assert.equal('node utils/setup.js && npm install --package-lock-only --ignore-scripts && npx npm-force-resolutions', packageDotJson.scripts.preinstall);
           assert.equal('node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js', packageDotJson.scripts.lint);
           assert.equal('node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js --quiet', packageDotJson.scripts['lint:errors']);
           assert.equal('mocha test/unit/adapterBaseTestUnit.js --LOG=error', packageDotJson.scripts['test:baseunit']);
@@ -363,6 +364,8 @@ describe('[unit] Netbox_v210 Adapter Test', () => {
           assert.equal('mocha test/integration/adapterTestIntegration.js --LOG=error', packageDotJson.scripts['test:integration']);
           assert.equal('nyc --reporter html --reporter text mocha --reporter dot test/*', packageDotJson.scripts['test:cover']);
           assert.equal('npm run test:baseunit && npm run test:unit && npm run test:integration', packageDotJson.scripts.test);
+          assert.equal('npm publish --registry=https://registry.npmjs.org --access=public', packageDotJson.scripts.deploy);
+          assert.equal('npm run deploy', packageDotJson.scripts.build);
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
@@ -375,6 +378,9 @@ describe('[unit] Netbox_v210 Adapter Test', () => {
           assert.notEqual(undefined, packageDotJson.repository);
           assert.notEqual(null, packageDotJson.repository);
           assert.notEqual('', packageDotJson.repository);
+          assert.equal('git', packageDotJson.repository.type);
+          assert.equal('git@gitlab.com:itentialopensource/adapters/', packageDotJson.repository.url.substring(0, 43));
+          assert.equal('https://gitlab.com/itentialopensource/adapters/', packageDotJson.homepage.substring(0, 47));
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
@@ -1126,6 +1132,18 @@ describe('[unit] Netbox_v210 Adapter Test', () => {
       });
     });
 
+    describe('#moveEntitiesToDB', () => {
+      it('should have a moveEntitiesToDB function', (done) => {
+        try {
+          assert.equal(true, typeof a.moveEntitiesToDB === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
     describe('#checkActionFiles', () => {
       it('should have a checkActionFiles function', (done) => {
         try {

package/utils/addAuth.js

@@ -0,0 +1,94 @@
+/* eslint-disable no-plusplus */
+/* eslint global-require: warn */
+/* eslint import/no-dynamic-require: warn */
+
+const rls = require('readline-sync');
+const path = require('path');
+const fs = require('fs');
+
+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/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/entitiesToDB.js

@@ -0,0 +1,224 @@
+/* @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 */
+
+/**
+ *  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 { MongoClient } = require('mongodb');
+const path = require('path');
+// const { argv } = require('process');
+// const { string } = require('yargs');
+
+// 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 = (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
+  optionsHandler(options).then((currentProps) => {
+    let mongoUrl;
+    let dbName;
+
+    // find the mongo properties so we can connect
+    if (currentProps.mongoProps) {
+      mongoUrl = currentProps.mongoProps.url;
+      dbName = currentProps.mongoProps.db;
+    } else if (currentProps.mongo) {
+      if (currentProps.mongo.url) {
+        mongoUrl = currentProps.mongo.url;
+      } else {
+        mongoUrl = `mongodb://${currentProps.mongo.host}:${currentProps.mongo.port}`;
+      }
+      dbName = currentProps.mongo.database;
+    } else {
+      throw new Error('Mongo properties are not specified in adapter preferences!');
+    }
+
+    // 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
+    MongoClient.connect(mongoUrl, (err, db) => {
+      if (err) {
+        log.error(JSON.stringify(err));
+        throw err;
+      }
+
+      // get the proper collection
+      const collection = db.db(dbName).collection(myOpts.targetCollection);
+      // insert the documents into the collection
+      collection.insertMany(docs, { checkKeys: false }, (error, res) => {
+        if (error) {
+          log.error(JSON.stringify(error));
+          throw error;
+        }
+        // log the insertion, close the database and return
+        log.debug(`Inserted ${docs.length} documents to ${dbName}.${myOpts.targetCollection} with response ${JSON.stringify(res)}`);
+        db.close();
+        return res;
+      });
+    });
+  });
+};
+
+// const args = process.argv.slice(2);
+
+// throw new SyntaxError(args[0]);
+
+// if (args.length === 0) {
+//   console.error('ERROR: target path not specified!');
+// } else if (args[0] === 'help') {
+//   log.trace('node ./entitiesToDB <target path> <options object: {iapDir: string, pronghornProps: string, targetCollection: string}>');
+// } else if (args.length === 1) {
+//   console.error('ERROR: IAP directory not specified');
+// } else {
+//   moveEntitiesToDB(args[0], args[1]);
+// }
+
+module.exports = { moveEntitiesToDB };

package/utils/modify.js

@@ -3,7 +3,7 @@ const Ajv = require('ajv');
 const rls = require('readline-sync');
 const { execSync } = require('child_process');
 const { existsSync } = require('fs-extra');
-const { getAdapterConfig } = require('./troubleshootingAdapter');
+const { getAdapterConfig } = require('./tbUtils');
 const { name } = require('../package.json');
 const propertiesSchema = require('../propertiesSchema.json');
 

package/utils/removeHooks.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+
+/**
+ * This script will uninstall pre-commit or pre-push hooks in case there's ever a need to
+ * commit/push something that has issues
+ */
+
+const precommitPath = '.git/hooks/pre-commit';
+const prepushPath = '.git/hooks/pre-push';
+fs.unlink(precommitPath, (err) => {
+  if (err && err.code !== 'ENOENT') {
+    console.log(`${err.message}`);
+  }
+});
+
+fs.unlink(prepushPath, (err) => {
+  if (err && err.code !== 'ENOENT') {
+    console.log(`${err.message}`);
+  }
+});

package/utils/tbScript.js

@@ -15,13 +15,18 @@ const basicGet = require('./basicGet');
 const { name } = require('../package.json');
 const sampleProperties = require('../sampleProperties.json');
 const adapterPronghorn = require('../pronghorn.json');
+const { addAuthInfo } = require('./addAuth');
 
-const { troubleshoot, getAdapterConfig, offline } = require('./troubleshootingAdapter');
+const { troubleshoot, offline } = require('./troubleshootingAdapter');
 
 const main = async (command) => {
-  const iapDir = path.join(__dirname, '../../../../');
+  const dirname = utils.getDirname();
+  const iapDir = path.join(dirname, '../../../');
   if (!utils.withinIAP(iapDir)) {
-    if (command === 'connectivity') {
+    if (command === 'install') {
+      console.log('Not currently in IAP directory - installation not possible');
+      process.exit(0);
+    } else if (command === 'connectivity') {
       const { host } = sampleProperties.properties;
       console.log(`perform networking diagnositics to ${host}`);
       await utils.runConnectivity(host);
@@ -43,7 +48,7 @@ const main = async (command) => {
   if (command === undefined) {
     await troubleshoot({}, true, true);
   } else if (command === 'install') {
-    const { database, serviceItem, pronghornProps } = await getAdapterConfig();
+    const { database, serviceItem, pronghornProps } = await utils.getAdapterConfig();
     const filter = { id: pronghornProps.id };
     const profileItem = await database.collection(utils.IAP_PROFILES_COLLECTION).findOne(filter);
     if (!profileItem) {
@@ -74,14 +79,16 @@ const main = async (command) => {
         process.exit(0);
       }
     } else {
-      utils.verifyInstallationDir(__dirname, name);
-      utils.npmInstall();
+      utils.verifyInstallationDir(dirname, name);
       utils.runTest();
       if (rls.keyInYN(`Do you want to install ${name} to IAP?`)) {
         console.log('Creating database entries...');
         const adapter = utils.createAdapter(
           pronghornProps, profileItem, sampleProperties, adapterPronghorn
         );
+
+        adapter.properties.properties = await addAuthInfo(adapter.properties.properties);
+
         await database.collection(utils.SERVICE_CONFIGS_COLLECTION).insertOne(adapter);
         profileItem.services.push(adapter.name);
         const update = { $set: { services: profileItem.services } };
@@ -94,7 +101,7 @@ const main = async (command) => {
       process.exit(0);
     }
   } else if (['healthcheck', 'basicget', 'connectivity'].includes(command)) {
-    const { serviceItem } = await getAdapterConfig();
+    const { serviceItem } = await utils.getAdapterConfig();
     if (serviceItem) {
       const adapter = serviceItem;
       const a = basicGet.getAdapterInstance(adapter);
@@ -154,7 +161,6 @@ program.parse(process.argv);
 if (process.argv.length < 3) {
   main();
 }
-
 const allowedParams = ['install', 'healthcheck', 'basicget', 'connectivity'];
 if (process.argv.length === 3 && !allowedParams.includes(process.argv[2])) {
   console.log(`unknown parameter ${process.argv[2]}`);

package/utils/tbUtils.js

@@ -100,8 +100,8 @@ module.exports = {
    *
    * @function decryptProperties
    */
-  decryptProperties: (props, dirname, discovery) => {
-    const propertyEncryptionClassPath = path.join(dirname, '../../../@itential/pronghorn-core/core/PropertyEncryption.js');
+  decryptProperties: (props, iapDir, discovery) => {
+    const propertyEncryptionClassPath = path.join(iapDir, 'node_modules/@itential/pronghorn-core/core/PropertyEncryption.js');
     const isEncrypted = props.pathProps.encrypted;
     const PropertyEncryption = discovery.require(propertyEncryptionClassPath, isEncrypted);
     const propertyEncryption = new PropertyEncryption({
@@ -177,12 +177,12 @@ module.exports = {
   verifyInstallationDir: (dirname, name) => {
     const pathArray = dirname.split(path.sep);
     const expectedPath = `node_modules/${name}`;
-    const currentPath = pathArray.slice(pathArray.length - 4, pathArray.length - 1).join('/');
-    if (expectedPath !== currentPath) {
-      throw new Error(`adapter should be installed under ${expectedPath}`);
+    const currentPath = pathArray.slice(pathArray.length - 3, pathArray.length).join('/');
+    if (currentPath.trim() !== expectedPath.trim()) {
+      throw new Error(`adapter should be installed under ${expectedPath} but is installed under ${currentPath}`);
     }
 
-    const serverFile = path.join(dirname, '../../../..', 'server.js');
+    const serverFile = path.join(dirname, '../../../', 'server.js');
     if (!fs.existsSync(serverFile)) {
       throw new Error(`adapter should be installed under IAP/${expectedPath}`);
     }
@@ -304,8 +304,9 @@ module.exports = {
    * @param {Object} adapterPronghorn - ./pronghorn.json in adapter dir
    * @param {Object} sampleProperties - './sampleProperties.json' in adapter dir
    */
-  createAdapter: (pronghornProps, profileItem, sampleProperties, adapterPronghorn) => {
-    const packagePath = `${__dirname.split('node_modules')[0]}package.json`;
+  createAdapter: function createAdapter(pronghornProps, profileItem, sampleProperties, adapterPronghorn) {
+    const dirname = this.getDirname();
+    const packagePath = `${dirname.split('node_modules')[0]}package.json`;
     const info = JSON.parse(fs.readFileSync(packagePath));
     const version = parseInt(info.version.split('.')[0], 10);
 
@@ -338,6 +339,37 @@ module.exports = {
     return adapter;
   },
 
+  getPronghornProps: function getPronghornProps(iapDir) {
+    console.log('Retrieving properties.json file...');
+    const rawProps = require(path.join(iapDir, 'properties.json'));
+    console.log('Decrypting properties...');
+    const { Discovery } = require(path.join(iapDir, 'node_modules/@itential/itential-utils'));
+    const discovery = new Discovery();
+    const pronghornProps = this.decryptProperties(rawProps, iapDir, discovery);
+    console.log('Found properties.\n');
+    return pronghornProps;
+  },
+
+  // get database connection and existing adapter config
+  getAdapterConfig: async function getAdapterConfig() {
+    const newDirname = this.getDirname();
+    let iapDir;
+    if (this.withinIAP(newDirname)) { // when this script is called from IAP
+      iapDir = newDirname;
+    } else {
+      iapDir = path.join(this.getDirname(), 'utils', '../../../../');
+    }
+    const pronghornProps = this.getPronghornProps(iapDir);
+    console.log('Connecting to Database...');
+    const database = await this.connect(iapDir, pronghornProps);
+    console.log('Connection established.');
+    const { name } = require(path.join(__dirname, '..', 'package.json'));
+    const serviceItem = await database.collection(this.SERVICE_CONFIGS_COLLECTION).findOne(
+      { model: name }
+    );
+    return { database, serviceItem, pronghornProps };
+  },
+
   /**
    * @summary return async healthcheck result as a Promise
    *
@@ -385,5 +417,35 @@ module.exports = {
     } catch (error) {
       return false;
     }
+  },
+
+  /**
+   * @summary Used to determine the proper dirname to return in case adapter reference is
+   * symlinked withink IAP
+   * @returns the symlinked path (using pwd command) of the adapter in case properties.json
+   * is not found in the original path
+   * @function getDirname
+   */
+  getDirname: function getDirname() {
+    if (this.withinIAP(path.join(__dirname, '../../../../'))) {
+      return __dirname;
+    }
+    const { stdout } = this.systemSync('pwd', true);
+    return stdout.trim();
+  },
+
+  /**
+   * @summary connect to mongodb
+   *
+   * @function connect
+   * @param {Object} properties - pronghornProps
+   */
+  connect: async function connect(iapDir, properties) {
+    // Connect to Mongo
+    const { MongoDBConnection } = require(path.join(iapDir, 'node_modules/@itential/database'));
+    const connection = new MongoDBConnection(properties.mongoProps);
+    const database = await connection.connect(true);
+    return database;
   }
+
 };

package/utils/troubleshootingAdapter.js

@@ -117,30 +117,6 @@ const VerifyHealthCheckEndpoint = (serviceItem, props, scriptFlag) => {
   return { result, updatedAdapter };
 };
 
-const getPronghornProps = (iapDir) => {
-  console.log('Retrieving properties.json file...');
-  const rawProps = require(path.join(iapDir, 'properties.json'));
-  console.log('Decrypting properties...');
-  const { Discovery } = require('@itential/itential-utils');
-  const discovery = new Discovery();
-  const pronghornProps = utils.decryptProperties(rawProps, __dirname, discovery);
-  console.log('Found properties.\n');
-  return pronghornProps;
-};
-
-// get database connection and existing adapter config
-const getAdapterConfig = async () => {
-  const iapDir = path.join(__dirname, '../../../../');
-  const pronghornProps = getPronghornProps(iapDir);
-  console.log('Connecting to Database...');
-  const database = await basicGet.connect(pronghornProps);
-  console.log('Connection established.');
-  const serviceItem = await database.collection(utils.SERVICE_CONFIGS_COLLECTION).findOne(
-    { model: name }
-  );
-  return { database, serviceItem, pronghornProps };
-};
-
 const offline = async () => {
   console.log('Start offline troubleshooting');
   const { updatedAdapter } = VerifyHealthCheckEndpoint({ properties: sampleProperties }, {}, true);
@@ -159,7 +135,7 @@ const offline = async () => {
 
 const troubleshoot = async (props, scriptFlag, persistFlag, adapter) => {
   // get database connection and existing adapter config
-  const { database, serviceItem } = await getAdapterConfig();
+  const { database, serviceItem } = await utils.getAdapterConfig();
   // where troubleshoot should start
   if (serviceItem) {
     if (!scriptFlag || rls.keyInYN(`Start verifying the connection and authentication properties for ${name}?`)) {
@@ -211,4 +187,4 @@ const troubleshoot = async (props, scriptFlag, persistFlag, adapter) => {
   return null;
 };
 
-module.exports = { troubleshoot, getAdapterConfig, offline };
+module.exports = { troubleshoot, offline };