@itentialopensource/adapter-viptela 0.8.0 → 0.10.0

package/adapterBase.js

@@ -8,6 +8,7 @@
 /* eslint no-cond-assign: warn */
 /* eslint global-require: warn */
 /* eslint no-unused-vars: warn */
+/* eslint prefer-destructuring: warn */
 
 /* Required libraries.  */
 const fs = require('fs-extra');
@@ -22,6 +23,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'));
 
@@ -153,6 +155,9 @@ class AdapterBase extends EventEmitterCl {
     // Instantiate the EventEmitter super class
     super();
 
+    // IAP home directory injected by core when running the adapter within IAP
+    process.env.iap_home = process.argv[3];
+
     try {
       // Capture the adapter id
       this.id = prongid;
@@ -247,6 +252,7 @@ class AdapterBase extends EventEmitterCl {
       // properties that this code cares about
       this.healthcheckType = this.allProps.healthcheck.type;
       this.healthcheckInterval = this.allProps.healthcheck.frequency;
+      this.healthcheckQuery = this.allProps.healthcheck.query_object;
 
       // set the failover codes from properties
       if (this.allProps.request.failover_codes) {
@@ -275,129 +281,6 @@ class AdapterBase extends EventEmitterCl {
     }
   }
 
-  /**
-   * updateAdapterConfiguration is used to update any of the adapter configuration files. This
-   * allows customers to make changes to adapter configuration without having to be on the
-   * file system.
-   *
-   * @function updateAdapterConfiguration
-   * @param {string} configFile - the name of the file being updated (required)
-   * @param {Object} changes - an object containing all of the changes = formatted like the configuration file (required)
-   * @param {string} entity - the entity to be changed, if an action, schema or mock data file (optional)
-   * @param {string} type - the type of entity file to change, (action, schema, mock) (optional)
-   * @param {string} action - the action to be changed, if an action, schema or mock data file (optional)
-   * @param {Callback} callback - The results of the call
-   */
-  updateAdapterConfiguration(configFile, changes, entity, type, action, callback) {
-    const meth = 'adapterBase-updateAdapterConfiguration';
-    const origin = `${this.id}-${meth}`;
-    log.trace(origin);
-
-    // verify the parameters are valid
-    if (changes === undefined || changes === null || typeof changes !== 'object'
-        || Object.keys(changes).length === 0) {
-      const result = {
-        response: 'No configuration updates to make'
-      };
-      log.info(result.response);
-      return callback(result, null);
-    }
-    if (configFile === undefined || configFile === null || configFile === '') {
-      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['configFile'], null, null, null);
-      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-      return callback(null, errorObj);
-    }
-
-    // take action based on configFile being changed
-    if (configFile === 'package.json') {
-      const pres = updatePackage(changes);
-      if (pres) {
-        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: ${pres}`, [], null, null, null);
-        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-        return callback(null, errorObj);
-      }
-      const result = {
-        response: 'Package updates completed - restarting adapter'
-      };
-      log.info(result.response);
-      forceFail(true);
-      return callback(result, null);
-    }
-    if (entity === undefined || entity === null || entity === '') {
-      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Unsupported Configuration Change or Missing Entity', [], null, null, null);
-      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-      return callback(null, errorObj);
-    }
-
-    // this means we are changing an entity file so type is required
-    if (type === undefined || type === null || type === '') {
-      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['type'], null, null, null);
-      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-      return callback(null, errorObj);
-    }
-
-    // if the entity does not exist - error
-    const epath = `${__dirname}/entities/${entity}`;
-    if (!fs.existsSync(epath)) {
-      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: Invalid Entity - ${entity}`, [], null, null, null);
-      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-      return callback(null, errorObj);
-    }
-
-    // take action based on type of file being changed
-    if (type === 'action') {
-      // BACKUP???
-      const ares = updateAction(epath, action, changes);
-      if (ares) {
-        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: ${ares}`, [], null, null, null);
-        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-        return callback(null, errorObj);
-      }
-      // AJV CHECK???
-      // RESTORE IF NEEDED???
-      const result = {
-        response: `Action updates completed to entity: ${entity} - ${action}`
-      };
-      log.info(result.response);
-      return callback(result, null);
-    }
-    if (type === 'schema') {
-      const sres = updateSchema(epath, configFile, changes);
-      if (sres) {
-        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: ${sres}`, [], null, null, null);
-        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-        return callback(null, errorObj);
-      }
-      const result = {
-        response: `Schema updates completed to entity: ${entity} - ${configFile}`
-      };
-      log.info(result.response);
-      return callback(result, null);
-    }
-    if (type === 'mock') {
-      // if the mock directory does not exist - error
-      const mpath = `${__dirname}/entities/${entity}/mockdatafiles`;
-      if (!fs.existsSync(mpath)) {
-        fs.mkdirSync(mpath);
-      }
-
-      const mres = updateMock(mpath, configFile, changes);
-      if (mres) {
-        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: ${mres}`, [], null, null, null);
-        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-        return callback(null, errorObj);
-      }
-      const result = {
-        response: `Mock data updates completed to entity: ${entity} - ${configFile}`
-      };
-      log.info(result.response);
-      return callback(result, null);
-    }
-    const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: Unsupported Type - ${type}`, [], null, null, null);
-    log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-    return callback(null, errorObj);
-  }
-
   /**
    * @summary Connect function is used during Pronghorn startup to provide instantiation feedback.
    *
@@ -451,8 +334,22 @@ class AdapterBase extends EventEmitterCl {
     const origin = `${this.id}-adapterBase-healthCheck`;
     log.trace(origin);
 
+    // if there is healthcheck query_object property, it needs to be added to the adapter
+    let myRequest = reqObj;
+    if (this.healthcheckQuery && Object.keys(this.healthcheckQuery).length > 0) {
+      if (myRequest && myRequest.uriQuery) {
+        myRequest.uriQuery = { ...myRequest.uriQuery, ...this.healthcheckQuery };
+      } else if (myRequest) {
+        myRequest.uriQuery = this.healthcheckQuery;
+      } else {
+        myRequest = {
+          uriQuery: this.healthcheckQuery
+        };
+      }
+    }
+
     // call to the healthcheck in connector
-    return this.requestHandlerInst.identifyHealthcheck(reqObj, (res, error) => {
+    return this.requestHandlerInst.identifyHealthcheck(myRequest, (res, error) => {
       // unhealthy
       if (error) {
         // if we were healthy, toggle health
@@ -485,98 +382,12 @@ class AdapterBase extends EventEmitterCl {
   }
 
   /**
-   * @summary Suspends the adapter
-   * @param {Callback} callback - The adapater suspension status
-   * @function suspend
-   */
-  suspend(mode, callback) {
-    const origin = `${this.id}-adapterBase-suspend`;
-    if (this.suspended) {
-      throw new Error(`${origin}: Adapter is already suspended`);
-    }
-    try {
-      this.suspended = true;
-      this.suspendMode = mode;
-      if (this.suspendMode === 'pause') {
-        const props = JSON.parse(JSON.stringify(this.initProps));
-        // To suspend adapter, enable throttling and set concurrent max to 0
-        props.throttle.throttle_enabled = true;
-        props.throttle.concurrent_max = 0;
-        this.refreshProperties(props);
-      }
-      return callback({ suspended: true });
-    } catch (error) {
-      return callback(null, error);
-    }
-  }
-
-  /**
-   * @summary Unsuspends the adapter
-   * @param {Callback} callback - The adapater suspension status
-   *
-   * @function unsuspend
-   */
-  unsuspend(callback) {
-    const origin = `${this.id}-adapterBase-unsuspend`;
-    if (!this.suspended) {
-      throw new Error(`${origin}: Adapter is not suspended`);
-    }
-    if (this.suspendMode === 'pause') {
-      const props = JSON.parse(JSON.stringify(this.initProps));
-      // To unsuspend adapter, keep throttling enabled and begin processing queued requests in order
-      props.throttle.throttle_enabled = true;
-      props.throttle.concurrent_max = 1;
-      this.refreshProperties(props);
-      setTimeout(() => {
-        this.getQueue((q, error) => {
-          // console.log("Items in queue: " + String(q.length))
-          if (q.length === 0) {
-            // if queue is empty, return to initial properties state
-            this.refreshProperties(this.initProps);
-            this.suspended = false;
-            return callback({ suspended: false });
-          }
-          // recursive call to check queue again every second
-          return this.unsuspend(callback);
-        });
-      }, 1000);
-    } else {
-      this.suspended = false;
-      callback({ suspend: false });
-    }
-  }
-
-  /**
-   * getAllFunctions is used to get all of the exposed function in the adapter
-   *
-   * @function getAllFunctions
-   */
-  getAllFunctions() {
-    let myfunctions = [];
-    let obj = this;
-
-    // find the functions in this class
-    do {
-      const l = Object.getOwnPropertyNames(obj)
-        .concat(Object.getOwnPropertySymbols(obj).map((s) => s.toString()))
-        .sort()
-        .filter((p, i, arr) => typeof obj[p] === 'function' && p !== 'constructor' && (i === 0 || p !== arr[i - 1]) && myfunctions.indexOf(p) === -1);
-      myfunctions = myfunctions.concat(l);
-    }
-    while (
-      (obj = Object.getPrototypeOf(obj)) && Object.getPrototypeOf(obj)
-    );
-
-    return myfunctions;
-  }
-
-  /**
-   * getWorkflowFunctions is used to get all of the workflow function in the adapter
+   * iapGetAdapterWorkflowFunctions is used to get all of the workflow function in the adapter
    * @param {array} ignoreThese - additional methods to ignore (optional)
    *
-   * @function getWorkflowFunctions
+   * @function iapGetAdapterWorkflowFunctions
    */
-  getWorkflowFunctions(ignoreThese) {
+  iapGetAdapterWorkflowFunctions(ignoreThese) {
     const myfunctions = this.getAllFunctions();
     const wffunctions = [];
 
@@ -586,8 +397,9 @@ class AdapterBase extends EventEmitterCl {
         // got to the second tier (adapterBase)
         break;
       }
-      if (myfunctions[m] !== 'hasEntity' && myfunctions[m] !== 'verifyCapability' && myfunctions[m] !== 'updateEntityCache'
-          && myfunctions[m] !== 'healthCheck' && myfunctions[m] !== 'getWorkflowFunctions'
+      if (myfunctions[m] !== 'iapHasAdapterEntity' && myfunctions[m] !== 'iapVerifyAdapterCapability'
+          && myfunctions[m] !== 'iapUpdateAdapterEntityCache' && myfunctions[m] !== 'healthCheck'
+          && myfunctions[m] !== 'iapGetAdapterWorkflowFunctions'
           && !(myfunctions[m].endsWith('Emit') || myfunctions[m].match(/Emit__v[0-9]+/))) {
         let found = false;
         if (ignoreThese && Array.isArray(ignoreThese)) {
@@ -601,36 +413,142 @@ class AdapterBase extends EventEmitterCl {
           wffunctions.push(myfunctions[m]);
         }
       }
-    }
-
-    return wffunctions;
-  }
-
-  /**
-   * checkActionFiles is used to update the validation of the action files.
-   *
-   * @function checkActionFiles
-   */
-  checkActionFiles() {
-    const origin = `${this.id}-adapterBase-checkActionFiles`;
-    log.trace(origin);
+    }
+
+    return wffunctions;
+  }
+
+  /**
+   * iapUpdateAdapterConfiguration is used to update any of the adapter configuration files. This
+   * allows customers to make changes to adapter configuration without having to be on the
+   * file system.
+   *
+   * @function iapUpdateAdapterConfiguration
+   * @param {string} configFile - the name of the file being updated (required)
+   * @param {Object} changes - an object containing all of the changes = formatted like the configuration file (required)
+   * @param {string} entity - the entity to be changed, if an action, schema or mock data file (optional)
+   * @param {string} type - the type of entity file to change, (action, schema, mock) (optional)
+   * @param {string} action - the action to be changed, if an action, schema or mock data file (optional)
+   * @param {Callback} callback - The results of the call
+   */
+  iapUpdateAdapterConfiguration(configFile, changes, entity, type, action, callback) {
+    const meth = 'adapterBase-iapUpdateAdapterConfiguration';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // verify the parameters are valid
+    if (changes === undefined || changes === null || typeof changes !== 'object'
+        || Object.keys(changes).length === 0) {
+      const result = {
+        response: 'No configuration updates to make'
+      };
+      log.info(result.response);
+      return callback(result, null);
+    }
+    if (configFile === undefined || configFile === null || configFile === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['configFile'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    // take action based on configFile being changed
+    if (configFile === 'package.json') {
+      const pres = updatePackage(changes);
+      if (pres) {
+        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: ${pres}`, [], null, null, null);
+        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+        return callback(null, errorObj);
+      }
+      const result = {
+        response: 'Package updates completed - restarting adapter'
+      };
+      log.info(result.response);
+      forceFail(true);
+      return callback(result, null);
+    }
+    if (entity === undefined || entity === null || entity === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Unsupported Configuration Change or Missing Entity', [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    // this means we are changing an entity file so type is required
+    if (type === undefined || type === null || type === '') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['type'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    // if the entity does not exist - error
+    const epath = `${__dirname}/entities/${entity}`;
+    if (!fs.existsSync(epath)) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: Invalid Entity - ${entity}`, [], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    // take action based on type of file being changed
+    if (type === 'action') {
+      // BACKUP???
+      const ares = updateAction(epath, action, changes);
+      if (ares) {
+        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: ${ares}`, [], null, null, null);
+        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+        return callback(null, errorObj);
+      }
+      // AJV CHECK???
+      // RESTORE IF NEEDED???
+      const result = {
+        response: `Action updates completed to entity: ${entity} - ${action}`
+      };
+      log.info(result.response);
+      return callback(result, null);
+    }
+    if (type === 'schema') {
+      const sres = updateSchema(epath, configFile, changes);
+      if (sres) {
+        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: ${sres}`, [], null, null, null);
+        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+        return callback(null, errorObj);
+      }
+      const result = {
+        response: `Schema updates completed to entity: ${entity} - ${configFile}`
+      };
+      log.info(result.response);
+      return callback(result, null);
+    }
+    if (type === 'mock') {
+      // if the mock directory does not exist - error
+      const mpath = `${__dirname}/entities/${entity}/mockdatafiles`;
+      if (!fs.existsSync(mpath)) {
+        fs.mkdirSync(mpath);
+      }
 
-    // validate the action files for the adapter
-    try {
-      return this.requestHandlerInst.checkActionFiles();
-    } catch (e) {
-      return ['Exception increase log level'];
+      const mres = updateMock(mpath, configFile, changes);
+      if (mres) {
+        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: ${mres}`, [], null, null, null);
+        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+        return callback(null, errorObj);
+      }
+      const result = {
+        response: `Mock data updates completed to entity: ${entity} - ${configFile}`
+      };
+      log.info(result.response);
+      return callback(result, null);
     }
+    const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Incomplete Configuration Change: Unsupported Type - ${type}`, [], null, null, null);
+    log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+    return callback(null, errorObj);
   }
 
   /**
    * See if the API path provided is found in this adapter
    *
-   * @function findPath
+   * @function iapFindAdapterPath
    * @param {string} apiPath - the api path to check on
    * @param {Callback} callback - The results of the call
    */
-  findPath(apiPath, callback) {
+  iapFindAdapterPath(apiPath, callback) {
     const result = {
       apiPath
     };
@@ -644,7 +562,7 @@ class AdapterBase extends EventEmitterCl {
     }
 
     // make sure the entities directory exists
-    const entitydir = path.join(__dirname, '../entities');
+    const entitydir = path.join(__dirname, 'entities');
     if (!fs.statSync(entitydir).isDirectory()) {
       log.error('Could not find the entities directory');
       result.found = false;
@@ -672,7 +590,7 @@ class AdapterBase extends EventEmitterCl {
               log.info(`          method: ${actions.actions[a].method} path: ${actions.actions[a].entitypath}`);
               const fitem = {
                 entity: entities[e],
-                action: actions[a].name,
+                action: actions.actions[a].name,
                 method: actions.actions[a].method,
                 path: actions.actions[a].entitypath
               };
@@ -707,66 +625,90 @@ class AdapterBase extends EventEmitterCl {
   }
 
   /**
-   * checkProperties is used to validate the adapter properties.
-   *
-   * @function checkProperties
-   * @param {Object} properties - an object containing all of the properties
+   * @summary Suspends the adapter
+   * @param {Callback} callback - The adapater suspension status
+   * @function iapSuspendAdapter
    */
-  checkProperties(properties) {
-    const origin = `${this.myid}-adapterBase-checkProperties`;
-    log.trace(origin);
-
-    // validate the properties for the adapter
+  iapSuspendAdapter(mode, callback) {
+    const origin = `${this.id}-adapterBase-iapSuspendAdapter`;
+    if (this.suspended) {
+      throw new Error(`${origin}: Adapter is already suspended`);
+    }
     try {
-      return this.requestHandlerInst.checkProperties(properties);
-    } catch (e) {
-      return { exception: 'Exception increase log level' };
+      this.suspended = true;
+      this.suspendMode = mode;
+      if (this.suspendMode === 'pause') {
+        const props = JSON.parse(JSON.stringify(this.initProps));
+        // To suspend adapter, enable throttling and set concurrent max to 0
+        props.throttle.throttle_enabled = true;
+        props.throttle.concurrent_max = 0;
+        this.refreshProperties(props);
+      }
+      return callback({ suspended: true });
+    } catch (error) {
+      return callback(null, error);
     }
   }
 
   /**
-   * getQueue is used to get information for all of the requests currently in the queue.
+   * @summary Unsuspends the adapter
+   * @param {Callback} callback - The adapater suspension status
    *
-   * @function getQueue
-   * @param {Callback} callback - a callback function to return the result (Queue) or the error
+   * @function iapUnsuspendAdapter
    */
-  getQueue(callback) {
-    const origin = `${this.id}-adapterBase-getQueue`;
-    log.trace(origin);
-
-    return this.requestHandlerInst.getQueue(callback);
+  iapUnsuspendAdapter(callback) {
+    const origin = `${this.id}-adapterBase-iapUnsuspendAdapter`;
+    if (!this.suspended) {
+      throw new Error(`${origin}: Adapter is not suspended`);
+    }
+    if (this.suspendMode === 'pause') {
+      const props = JSON.parse(JSON.stringify(this.initProps));
+      // To unsuspend adapter, keep throttling enabled and begin processing queued requests in order
+      props.throttle.throttle_enabled = true;
+      props.throttle.concurrent_max = 1;
+      this.refreshProperties(props);
+      setTimeout(() => {
+        this.getQueue((q, error) => {
+          // console.log("Items in queue: " + String(q.length))
+          if (q.length === 0) {
+            // if queue is empty, return to initial properties state
+            this.refreshProperties(this.initProps);
+            this.suspended = false;
+            return callback({ suspended: false });
+          }
+          // recursive call to check queue again every second
+          return this.iapUnsuspendAdapter(callback);
+        });
+      }, 1000);
+    } else {
+      this.suspended = false;
+      callback({ suspend: false });
+    }
   }
 
   /**
-   * @summary Takes in property text and an encoding/encryption and returns the resulting
-   * encoded/encrypted string
-   *
-   * @function encryptProperty
-   * @param {String} property - the property to encrypt
-   * @param {String} technique - the technique to use to encrypt
+   * iapGetAdapterQueue is used to get information for all of the requests currently in the queue.
    *
-   * @param {Callback} callback - a callback function to return the result
-   *                              Encrypted String or the Error
+   * @function iapGetAdapterQueue
+   * @param {Callback} callback - a callback function to return the result (Queue) or the error
    */
-  encryptProperty(property, technique, callback) {
-    const origin = `${this.id}-adapterBase-encryptProperty`;
+  iapGetAdapterQueue(callback) {
+    const origin = `${this.id}-adapterBase-iapGetAdapterQueue`;
     log.trace(origin);
 
-    // Make the call -
-    // encryptProperty(property, technique, callback)
-    return this.requestHandlerInst.encryptProperty(property, technique, callback);
+    return this.requestHandlerInst.getQueue(callback);
   }
 
   /**
    * @summary runs troubleshoot scripts for adapter
    *
-   * @function troubleshoot
+   * @function iapTroubleshootAdapter
    * @param {Object} props - the connection, healthcheck and authentication properties
    * @param {boolean} persistFlag - whether the adapter properties should be updated
    * @param {Adapter} adapter - adapter instance to troubleshoot
    * @param {Callback} callback - callback function to return troubleshoot results
    */
-  async troubleshoot(props, persistFlag, adapter, callback) {
+  async iapTroubleshootAdapter(props, persistFlag, adapter, callback) {
     try {
       const result = await troubleshootingAdapter.troubleshoot(props, false, persistFlag, adapter);
       if (result.healthCheck && result.connectivity.failCount === 0 && result.basicGet.failCount === 0) {
@@ -781,11 +723,11 @@ class AdapterBase extends EventEmitterCl {
   /**
    * @summary runs healthcheck script for adapter
    *
-   * @function runHealthcheck
+   * @function iapRunAdapterHealthcheck
    * @param {Adapter} adapter - adapter instance to troubleshoot
    * @param {Callback} callback - callback function to return healthcheck status
    */
-  async runHealthcheck(adapter, callback) {
+  async iapRunAdapterHealthcheck(adapter, callback) {
     try {
       const result = await tbUtils.healthCheck(adapter);
       if (result) {
@@ -800,13 +742,13 @@ class AdapterBase extends EventEmitterCl {
   /**
    * @summary runs connectivity check script for adapter
    *
-   * @function runConnectivity
+   * @function iapRunAdapterConnectivity
    * @param {Adapter} adapter - adapter instance to troubleshoot
    * @param {Callback} callback - callback function to return connectivity status
    */
-  async runConnectivity(callback) {
+  async iapRunAdapterConnectivity(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) {
@@ -821,10 +763,10 @@ class AdapterBase extends EventEmitterCl {
   /**
    * @summary runs basicGet script for adapter
    *
-   * @function runBasicGet
+   * @function iapRunAdapterBasicGet
    * @param {Callback} callback - callback function to return basicGet result
    */
-  runBasicGet(callback) {
+  iapRunAdapterBasicGet(callback) {
     try {
       const result = tbUtils.runBasicGet(false);
       if (result.failCount > 0) {
@@ -836,6 +778,106 @@ class AdapterBase extends EventEmitterCl {
     }
   }
 
+  /**
+   * @summary moves entities to mongo database
+   *
+   * @function iapMoveAdapterEntitiesToDB
+   *
+   * @return {Callback} - containing the response from the mongo transaction
+   */
+  iapMoveAdapterEntitiesToDB(callback) {
+    const meth = 'adapterBase-iapMoveAdapterEntitiesToDB';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      return callback(entitiesToDB.iapMoveAdapterEntitiesToDB(__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);
+    }
+  }
+
+  /**
+   * getAllFunctions is used to get all of the exposed function in the adapter
+   *
+   * @function getAllFunctions
+   */
+  getAllFunctions() {
+    let myfunctions = [];
+    let obj = this;
+
+    // find the functions in this class
+    do {
+      const l = Object.getOwnPropertyNames(obj)
+        .concat(Object.getOwnPropertySymbols(obj).map((s) => s.toString()))
+        .sort()
+        .filter((p, i, arr) => typeof obj[p] === 'function' && p !== 'constructor' && (i === 0 || p !== arr[i - 1]) && myfunctions.indexOf(p) === -1);
+      myfunctions = myfunctions.concat(l);
+    }
+    while (
+      (obj = Object.getPrototypeOf(obj)) && Object.getPrototypeOf(obj)
+    );
+
+    return myfunctions;
+  }
+
+  /**
+   * checkActionFiles is used to update the validation of the action files.
+   *
+   * @function checkActionFiles
+   */
+  checkActionFiles() {
+    const origin = `${this.id}-adapterBase-checkActionFiles`;
+    log.trace(origin);
+
+    // validate the action files for the adapter
+    try {
+      return this.requestHandlerInst.checkActionFiles();
+    } catch (e) {
+      return ['Exception increase log level'];
+    }
+  }
+
+  /**
+   * checkProperties is used to validate the adapter properties.
+   *
+   * @function checkProperties
+   * @param {Object} properties - an object containing all of the properties
+   */
+  checkProperties(properties) {
+    const origin = `${this.myid}-adapterBase-checkProperties`;
+    log.trace(origin);
+
+    // validate the properties for the adapter
+    try {
+      return this.requestHandlerInst.checkProperties(properties);
+    } catch (e) {
+      return { exception: 'Exception increase log level' };
+    }
+  }
+
+  /**
+   * @summary Takes in property text and an encoding/encryption and returns the resulting
+   * encoded/encrypted string
+   *
+   * @function encryptProperty
+   * @param {String} property - the property to encrypt
+   * @param {String} technique - the technique to use to encrypt
+   *
+   * @param {Callback} callback - a callback function to return the result
+   *                              Encrypted String or the Error
+   */
+  encryptProperty(property, technique, callback) {
+    const origin = `${this.id}-adapterBase-encryptProperty`;
+    log.trace(origin);
+
+    // Make the call -
+    // encryptProperty(property, technique, callback)
+    return this.requestHandlerInst.encryptProperty(property, technique, callback);
+  }
+
   /**
    * @summary take the entities and add them to the cache
    *
@@ -986,6 +1028,266 @@ class AdapterBase extends EventEmitterCl {
       return [];
     }
   }
+
+  /**
+   * @summary Make one of the needed Broker calls - could be one of many
+   *
+   * @function iapMakeBrokerCall
+   * @param {string} brokCall - the name of the broker call (required)
+   * @param {object} callProps - the proeprties for the broker call (required)
+   * @param {object} devResp - the device details to extract needed inputs (required)
+   * @param {string} filterName - any filter to search on (required)
+   *
+   * @param {getCallback} callback - a callback function to return the result of the call
+   */
+  iapMakeBrokerCall(brokCall, callProps, devResp, filterName, callback) {
+    const meth = 'adapter-iapMakeBrokerCall';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    try {
+      let uriPath = '';
+      let uriMethod = 'GET';
+      let callQuery = {};
+      let callBody = {};
+      let callHeaders = {};
+      let handleFail = 'fail';
+      let ostypePrefix = '';
+      let statusValue = 'true';
+      if (callProps.path) {
+        uriPath = `${callProps.path}`;
+
+        // make any necessary changes to the path
+        if (devResp && callProps.requestFields && Object.keys(callProps.requestFields).length > 0) {
+          const rqKeys = Object.keys(callProps.requestFields);
+
+          // get the field from the provided device
+          for (let rq = 0; rq < rqKeys.length; rq += 1) {
+            // get the request field we are retrieving
+            const loopField = callProps.requestFields[rqKeys[rq]];
+            const loopArray = loopField.split('.');
+            let nestedValue = devResp;
+
+            // loops through incase the field is nested
+            for (let i = 0; i < loopArray.length; i += 1) {
+              if (Object.hasOwnProperty.call(nestedValue, loopArray[i])) {
+                nestedValue = nestedValue[loopArray[i]];
+              } else {
+                // failed to traverse
+                nestedValue = '';
+                break;
+              }
+            }
+
+            // put the value into the path - if it has been specified in the path
+            uriPath = uriPath.replace(rqKeys[rq], nestedValue);
+          }
+        }
+      }
+      if (callProps.method) {
+        uriMethod = callProps.method;
+      }
+      if (callProps.query) {
+        callQuery = callProps.query;
+
+        // go through the query params to check for variable values
+        const cpKeys = Object.keys(callQuery);
+        for (let cp = 0; cp < cpKeys.length; cp += 1) {
+          if (callQuery[cpKeys[cp]].startsWith('{') && callQuery[cpKeys[cp]].endsWith('}')) {
+            // make any necessary changes to the query params
+            if (devResp && callProps.requestFields && Object.keys(callProps.requestFields).length > 0) {
+              const rqKeys = Object.keys(callProps.requestFields);
+
+              // get the uuid from the device
+              for (let rq = 0; rq < rqKeys.length; rq += 1) {
+                if (cpKeys[cp] === rqKeys[rq]) {
+                  // get the request field we are retrieving
+                  const loopField = callProps.requestFields[rqKeys[rq]];
+                  const loopArray = loopField.split('.');
+                  let nestedValue = devResp;
+
+                  // loops through incase the field is nested
+                  for (let i = 0; i < loopArray.length; i += 1) {
+                    if (Object.hasOwnProperty.call(nestedValue, loopArray[i])) {
+                      nestedValue = nestedValue[loopArray[i]];
+                    } else {
+                      // failed to traverse
+                      nestedValue = '';
+                      break;
+                    }
+                  }
+
+                  // put the value into the query - if it has been specified in the query
+                  callQuery[cpKeys[cp]] = nestedValue;
+                }
+              }
+            }
+          }
+        }
+      }
+      if (callProps.body) {
+        callBody = callProps.body;
+      }
+      if (callProps.headers) {
+        callHeaders = callProps.headers;
+      }
+      if (callProps.handleFailure) {
+        handleFail = callProps.handleFailure;
+      }
+      if (callProps.responseFields && callProps.responseFields.ostypePrefix) {
+        ostypePrefix = callProps.responseFields.ostypePrefix;
+      }
+      if (callProps.responseFields && callProps.statusValue) {
+        statusValue = callProps.statusValue;
+      }
+
+      // !! using Generic makes it easier on the Adapter Builder (just need to change the path)
+      // !! you can also replace with a specific call if that is easier
+      return this.genericAdapterRequest(uriPath, uriMethod, callQuery, callBody, callHeaders, (result, error) => {
+        // if we received an error or their is no response on the results return an error
+        if (error) {
+          if (handleFail === 'fail') {
+            return callback(null, error);
+          }
+          return callback({}, null);
+        }
+        if (!result.response) {
+          if (handleFail === 'fail') {
+            const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', [brokCall], null, null, null);
+            log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+            return callback(null, errorObj);
+          }
+          return callback({}, null);
+        }
+
+        // get the keys for the response fields
+        let rfKeys = [];
+        if (callProps.responseFields && Object.keys(callProps.responseFields) > 0) {
+          rfKeys = Object.keys(callProps.responseFields);
+        }
+
+        // if we got an array returned (e.g. getDevicesFitered)
+        if (Array.isArray(result.response)) {
+          const listDevices = [];
+          for (let a = 0; a < result.response.length; a += 1) {
+            const thisDevice = result.response[a];
+            for (let rf = 0; rf < rfKeys.length; rf += 1) {
+              if (rfKeys[rf] !== 'ostypePrefix') {
+                // get the response field we are retrieving
+                const loopField = callProps.responseFields[rfKeys[rf]];
+                const loopArray = loopField.split('.');
+                let nestedValue = thisDevice;
+
+                // loops through incase the field is nested
+                for (let i = 0; i < loopArray.length; i += 1) {
+                  if (Object.hasOwnProperty.call(nestedValue, loopArray[i])) {
+                    nestedValue = nestedValue[loopArray[i]];
+                  } else {
+                    // failed to traverse
+                    nestedValue = '';
+                    break;
+                  }
+                }
+                // if the field is ostype - need to add prefix
+                if (rfKeys[rf] === 'ostype' && typeof nestedValue === 'string') {
+                  nestedValue = ostypePrefix + nestedValue;
+                }
+                // if there is a status to set, set it
+                if (rfKeys[rf] === 'status') {
+                  if (nestedValue.toString() === statusValue.toString()) {
+                    thisDevice.isAlive = true;
+                  } else {
+                    thisDevice.isAlive = false;
+                  }
+                }
+                // if we found a good value
+                thisDevice[rfKeys[rf]] = nestedValue;
+              }
+            }
+
+            // if there is no filter - add the device to the list
+            if (!filterName || filterName.length === 0) {
+              listDevices.push(thisDevice);
+            } else {
+              // if we have to match a filter
+              let found = false;
+              for (let f = 0; f < filterName.length; f += 1) {
+                if (thisDevice.name.indexOf(filterName[f]) >= 0) {
+                  found = true;
+                  break;
+                }
+              }
+              // matching device
+              if (found) {
+                listDevices.push(thisDevice);
+              }
+            }
+          }
+
+          // return the array of devices
+          return callback(listDevices, null);
+        }
+
+        // if this is not an array - just about everything else, just handle as a single object
+        let thisDevice = result.response;
+        for (let rf = 0; rf < rfKeys.length; rf += 1) {
+          // skip ostypePrefix since it is not a field
+          if (rfKeys[rf] !== 'ostypePrefix') {
+            // get the response field we are retrieving
+            const loopField = callProps.responseFields[rfKeys[rf]];
+            const loopArray = loopField.split('.');
+            let nestedValue = thisDevice;
+
+            // loops through incase the field is nested
+            for (let i = 0; i < loopArray.length; i += 1) {
+              if (Object.hasOwnProperty.call(nestedValue, loopArray[i])) {
+                nestedValue = nestedValue[loopArray[i]];
+              } else {
+                // failed to traverse
+                nestedValue = '';
+                break;
+              }
+            }
+            // if the field is ostype - need to add prefix
+            if (rfKeys[rf] === 'ostype' && typeof nestedValue === 'string') {
+              nestedValue = ostypePrefix + nestedValue;
+            }
+            // if there is a status to set, set it
+            if (rfKeys[rf] === 'status') {
+              if (nestedValue.toString() === statusValue.toString()) {
+                thisDevice.isAlive = true;
+              } else {
+                thisDevice.isAlive = false;
+              }
+            }
+            // if we found a good value
+            thisDevice[rfKeys[rf]] = nestedValue;
+          }
+        }
+
+        // if there is a filter - check the device is in the list
+        if (filterName && filterName.length > 0) {
+          let found = false;
+          for (let f = 0; f < filterName.length; f += 1) {
+            if (thisDevice.name.indexOf(filterName[f]) >= 0) {
+              found = true;
+              break;
+            }
+          }
+          // no matching device - clear the device
+          if (!found) {
+            thisDevice = {};
+          }
+        }
+
+        return callback(thisDevice, null);
+      });
+    } catch (e) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, e);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
 }
 
 module.exports = AdapterBase;