@itentialopensource/adapter-dna_center 0.5.7 → 0.6.0

package/adapterBase.js

@@ -13,6 +13,7 @@
 /* Required libraries.  */
 const fs = require('fs-extra');
 const path = require('path');
+const jsonQuery = require('json-query');
 const EventEmitterCl = require('events').EventEmitter;
 const { execSync } = require('child_process');
 
@@ -144,6 +145,27 @@ function updatePackage(changes) {
   return null;
 }
 
+/*
+ * INTERNAL FUNCTION: get data from source(s) - nested
+ */
+function getDataFromSources(loopField, sources) {
+  let fieldValue = loopField;
+
+  // go through the sources to find the field
+  for (let s = 0; s < sources.length; s += 1) {
+    // find the field value using jsonquery
+    const nestedValue = jsonQuery(loopField, { data: sources[s] }).value;
+
+    // if we found in source - set and no need to check other sources
+    if (nestedValue) {
+      fieldValue = nestedValue;
+      break;
+    }
+  }
+
+  return fieldValue;
+}
+
 /* GENERAL ADAPTER FUNCTIONS THESE SHOULD NOT BE DIRECTLY MODIFIED */
 /* IF YOU NEED MODIFICATIONS, REDEFINE THEM IN adapter.js!!! */
 class AdapterBase extends EventEmitterCl {
@@ -156,7 +178,7 @@ class AdapterBase extends EventEmitterCl {
     super();
 
     // IAP home directory injected by core when running the adapter within IAP
-    process.env.iap_home = process.argv[3];
+    [, , , process.env.iap_home] = process.argv;
 
     try {
       // Capture the adapter id
@@ -381,6 +403,85 @@ class AdapterBase extends EventEmitterCl {
     });
   }
 
+  /**
+   * 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);
+  }
+
   /**
    * iapGetAdapterWorkflowFunctions is used to get all of the workflow function in the adapter
    * @param {array} ignoreThese - additional methods to ignore (optional)
@@ -397,10 +498,7 @@ class AdapterBase extends EventEmitterCl {
         // got to the second tier (adapterBase)
         break;
       }
-      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]+/))) {
+      if (!(myfunctions[m].endsWith('Emit') || myfunctions[m].match(/Emit__v[0-9]+/))) {
         let found = false;
         if (ignoreThese && Array.isArray(ignoreThese)) {
           for (let i = 0; i < ignoreThese.length; i += 1) {
@@ -785,99 +883,21 @@ class AdapterBase extends EventEmitterCl {
    *
    * @return {Callback} - containing the response from the mongo transaction
    */
-  iapMoveAdapterEntitiesToDB(callback) {
+  async 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);
+      const result = await entitiesToDB.moveEntitiesToDB(__dirname, { pronghornProps: this.allProps, id: this.id });
+      return callback(result, 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);
+      return callback(null, err.message);
     }
   }
 
-  /**
-   * 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
    *
@@ -1029,6 +1049,67 @@ class AdapterBase extends EventEmitterCl {
     }
   }
 
+  /**
+   * @summary Determines if this adapter supports any in a list of entities
+   *
+   * @function hasEntities
+   * @param {String} entityType - the entity type to check for
+   * @param {Array} entityList - the list of entities we are looking for
+   *
+   * @param {Callback} callback - A map where the entity is the key and the
+   *                              value is true or false
+   */
+  hasEntities(entityType, entityList, callback) {
+    const origin = `${this.id}-adapter-hasEntities`;
+    log.trace(origin);
+
+    switch (entityType) {
+      case 'Device':
+        return this.hasDevices(entityList, callback);
+      default:
+        return callback(null, `${this.id} does not support entity ${entityType}`);
+    }
+  }
+
+  /**
+   * @summary Helper method for hasEntities for the specific device case
+   *
+   * @param {Array} deviceList - array of unique device identifiers
+   * @param {Callback} callback - A map where the device is the key and the
+   *                              value is true or false
+   */
+  hasDevices(deviceList, callback) {
+    const origin = `${this.id}-adapter-hasDevices`;
+    log.trace(origin);
+
+    const findings = deviceList.reduce((map, device) => {
+      // eslint-disable-next-line no-param-reassign
+      map[device] = false;
+      log.debug(`In reduce: ${JSON.stringify(map)}`);
+      return map;
+    }, {});
+    const apiCalls = deviceList.map((device) => new Promise((resolve) => {
+      this.getDevice(device, (result, error) => {
+        if (error) {
+          log.debug(`In map error: ${JSON.stringify(device)}`);
+          return resolve({ name: device, found: false });
+        }
+        log.debug(`In map: ${JSON.stringify(device)}`);
+        return resolve({ name: device, found: true });
+      });
+    }));
+    Promise.all(apiCalls).then((results) => {
+      results.forEach((device) => {
+        findings[device.name] = device.found;
+      });
+      log.debug(`FINDINGS: ${JSON.stringify(findings)}`);
+      return callback(findings);
+    }).catch((errors) => {
+      log.error('Unable to do device lookup.');
+      return callback(null, { code: 503, message: 'Unable to do device lookup.', error: errors });
+    });
+  }
+
   /**
    * @summary Make one of the needed Broker calls - could be one of many
    *
@@ -1041,7 +1122,7 @@ class AdapterBase extends EventEmitterCl {
    * @param {getCallback} callback - a callback function to return the result of the call
    */
   iapMakeBrokerCall(brokCall, callProps, devResp, filterName, callback) {
-    const meth = 'adapter-iapMakeBrokerCall';
+    const meth = 'adapterBase-iapMakeBrokerCall';
     const origin = `${this.id}-${meth}`;
     log.trace(origin);
 
@@ -1063,24 +1144,10 @@ class AdapterBase extends EventEmitterCl {
 
           // 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 = loopField;
-                break;
-              }
-            }
+            const fieldValue = getDataFromSources(callProps.requestFields[rqKeys[rq]], devResp);
 
             // put the value into the path - if it has been specified in the path
-            uriPath = uriPath.replace(`{${rqKeys[rq]}}`, nestedValue);
+            uriPath = uriPath.replace(`{${rqKeys[rq]}}`, fieldValue);
           }
         }
       }
@@ -1098,27 +1165,13 @@ class AdapterBase extends EventEmitterCl {
             if (devResp !== null && callProps.requestFields && Object.keys(callProps.requestFields).length > 0) {
               const rqKeys = Object.keys(callProps.requestFields);
 
-              // get the uuid from the device
+              // get the field from the provided 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 = loopField;
-                      break;
-                    }
-                  }
+                  const fieldValue = getDataFromSources(callProps.requestFields[rqKeys[rq]], devResp);
 
                   // put the value into the query - if it has been specified in the query
-                  callQuery[cpKeys[cp]] = nestedValue;
+                  callQuery[cpKeys[cp]] = fieldValue;
                 }
               }
             }
@@ -1127,9 +1180,51 @@ class AdapterBase extends EventEmitterCl {
       }
       if (callProps.body) {
         callBody = callProps.body;
+
+        // go through the body fields to check for variable values
+        const cbKeys = Object.keys(callBody);
+        for (let cb = 0; cb < cbKeys.length; cb += 1) {
+          if (callBody[cbKeys[cb]].startsWith('{') && callBody[cbKeys[cb]].endsWith('}')) {
+            // make any necessary changes to the query params
+            if (devResp !== null && 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) {
+                if (cbKeys[cb] === rqKeys[rq]) {
+                  const fieldValue = getDataFromSources(callProps.requestFields[rqKeys[rq]], devResp);
+
+                  // put the value into the query - if it has been specified in the query
+                  callBody[cbKeys[cb]] = fieldValue;
+                }
+              }
+            }
+          }
+        }
       }
       if (callProps.headers) {
         callHeaders = callProps.headers;
+
+        // go through the body fields to check for variable values
+        const chKeys = Object.keys(callHeaders);
+        for (let ch = 0; ch < chKeys.length; ch += 1) {
+          if (callHeaders[chKeys[ch]].startsWith('{') && callHeaders[chKeys[ch]].endsWith('}')) {
+            // make any necessary changes to the query params
+            if (devResp !== null && 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) {
+                if (chKeys[ch] === rqKeys[rq]) {
+                  const fieldValue = getDataFromSources(callProps.requestFields[rqKeys[rq]], devResp);
+
+                  // put the value into the query - if it has been specified in the query
+                  callHeaders[chKeys[ch]] = fieldValue;
+                }
+              }
+            }
+          }
+        }
       }
       if (callProps.handleFailure) {
         handleFail = callProps.handleFailure;
@@ -1160,6 +1255,12 @@ class AdapterBase extends EventEmitterCl {
           return callback({}, null);
         }
 
+        // get the response piece we care about from the response
+        const myResult = result;
+        if (callProps.responseDatakey) {
+          myResult.response = jsonQuery(callProps.responseDatakey, { data: myResult.response }).value;
+        }
+
         // get the keys for the response fields
         let rfKeys = [];
         if (callProps.responseFields && Object.keys(callProps.responseFields).length > 0) {
@@ -1167,44 +1268,31 @@ class AdapterBase extends EventEmitterCl {
         }
 
         // if we got an array returned (e.g. getDevicesFitered)
-        if (Array.isArray(result.response)) {
+        if (Array.isArray(myResult.response)) {
           const listDevices = [];
-          for (let a = 0; a < result.response.length; a += 1) {
-            const thisDevice = result.response[a];
+          for (let a = 0; a < myResult.response.length; a += 1) {
+            const thisDevice = myResult.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;
-                  }
-                }
+                let fieldValue = getDataFromSources(callProps.responseFields[rfKeys[rf]], [thisDevice, devResp, callProps.requestFields]);
+
                 // if the field is ostype - need to add prefix
-                if (rfKeys[rf] === 'ostype' && typeof nestedValue === 'string') {
-                  nestedValue = ostypePrefix + nestedValue;
+                if (rfKeys[rf] === 'ostype' && typeof fieldValue === 'string') {
+                  fieldValue = ostypePrefix + fieldValue;
                 }
                 // if there is a status to set, set it
                 if (rfKeys[rf] === 'status') {
                   // if really looking for just a good response
-                  if (loopField === 'return2xx' && result.icode === statusValue.toString()) {
+                  if (callProps.responseFields[rfKeys[rf]] === 'return2xx' && myResult.icode === statusValue.toString()) {
                     thisDevice.isAlive = true;
-                  } else if (nestedValue.toString() === statusValue.toString()) {
+                  } else if (fieldValue.toString() === statusValue.toString()) {
                     thisDevice.isAlive = true;
                   } else {
                     thisDevice.isAlive = false;
                   }
                 }
                 // if we found a good value
-                thisDevice[rfKeys[rf]] = nestedValue;
+                thisDevice[rfKeys[rf]] = fieldValue;
               }
             }
 
@@ -1232,42 +1320,29 @@ class AdapterBase extends EventEmitterCl {
         }
 
         // if this is not an array - just about everything else, just handle as a single object
-        let thisDevice = result.response;
+        let thisDevice = myResult.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;
-              }
-            }
+            let fieldValue = getDataFromSources(callProps.responseFields[rfKeys[rf]], [thisDevice, devResp, callProps.requestFields]);
+
             // if the field is ostype - need to add prefix
-            if (rfKeys[rf] === 'ostype' && typeof nestedValue === 'string') {
-              nestedValue = ostypePrefix + nestedValue;
+            if (rfKeys[rf] === 'ostype' && typeof fieldValue === 'string') {
+              fieldValue = ostypePrefix + fieldValue;
             }
             // if there is a status to set, set it
             if (rfKeys[rf] === 'status') {
               // if really looking for just a good response
-              if (loopField === 'return2xx' && result.icode === statusValue.toString()) {
+              if (callProps.responseFields[rfKeys[rf]] === 'return2xx' && myResult.icode === statusValue.toString()) {
                 thisDevice.isAlive = true;
-              } else if (nestedValue.toString() === statusValue.toString()) {
+              } else if (fieldValue.toString() === statusValue.toString()) {
                 thisDevice.isAlive = true;
               } else {
                 thisDevice.isAlive = false;
               }
             }
             // if we found a good value
-            thisDevice[rfKeys[rf]] = nestedValue;
+            thisDevice[rfKeys[rf]] = fieldValue;
           }
         }
 
@@ -1294,6 +1369,414 @@ class AdapterBase extends EventEmitterCl {
       return callback(null, errorObj);
     }
   }
+
+  /**
+   * @summary Get Appliance that match the deviceName
+   *
+   * @function getDevice
+   * @param {String} deviceName - the deviceName to find (required)
+   *
+   * @param {getCallback} callback - a callback function to return the result
+   *                                 (appliance) or the error
+   */
+  getDevice(deviceName, callback) {
+    const meth = 'adapterBase-getDevice';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker getDevice
+    if (!this.allProps.devicebroker || !this.allProps.devicebroker.getDevice || this.allProps.devicebroker.getDevice.length === 0 || !this.allProps.devicebroker.getDevice[0].path) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Properties', ['devicebroker.getDevice.path'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    /* HERE IS WHERE YOU VALIDATE DATA */
+    if (deviceName === undefined || deviceName === null || deviceName === '' || deviceName.length === 0) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['deviceName'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    try {
+      // need to get the device so we can convert the deviceName to an id
+      // !! if we can do a lookup by name the getDevicesFiltered may not be necessary
+      const opts = {
+        filter: {
+          name: deviceName
+        }
+      };
+      return this.getDevicesFiltered(opts, (devs, ferr) => {
+        // if we received an error or their is no response on the results return an error
+        if (ferr) {
+          return callback(null, ferr);
+        }
+        if (devs.list.length < 1) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Did Not Find Device ${deviceName}`, [], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        const callPromises = [];
+        for (let i = 0; i < this.allProps.devicebroker.getDevice.length; i += 1) {
+          // Perform component calls here.
+          callPromises.push(
+            new Promise((resolve, reject) => {
+              this.iapMakeBrokerCall('getDevice', this.allProps.devicebroker.getDevice[i], [devs.list[0]], null, (callRet, callErr) => {
+                // return an error
+                if (callErr) {
+                  reject(callErr);
+                } else {
+                  // return the data
+                  resolve(callRet);
+                }
+              });
+            })
+          );
+        }
+
+        // return an array of repsonses
+        return Promise.all(callPromises).then((results) => {
+          let myResult = {};
+          results.forEach((result) => {
+            myResult = { ...myResult, ...result };
+          });
+
+          return callback(myResult, null);
+        });
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Get Appliances that match the filter
+   *
+   * @function getDevicesFiltered
+   * @param {Object} options - the data to use to filter the appliances (optional)
+   *
+   * @param {getCallback} callback - a callback function to return the result
+   *                                 (appliances) or the error
+   */
+  getDevicesFiltered(options, callback) {
+    const meth = 'adapterBase-getDevicesFiltered';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker getDevicesFiltered
+    if (!this.allProps.devicebroker || !this.allProps.devicebroker.getDevicesFiltered || this.allProps.devicebroker.getDevicesFiltered.length === 0 || !this.allProps.devicebroker.getDevicesFiltered[0].path) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Properties', ['devicebroker.getDevicesFiltered.path'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    // verify the required fields have been provided
+    if (options === undefined || options === null || options === '' || options.length === 0) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['options'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+    log.debug(`Device Filter Options: ${JSON.stringify(options)}`);
+
+    try {
+      // TODO - get pagination working
+      // const nextToken = options.start;
+      // const maxResults = options.limit;
+
+      // set up the filter of Device Names
+      let filterName = [];
+      if (options && options.filter && options.filter.name) {
+        // when this hack is removed, remove the lint ignore above
+        if (Array.isArray(options.filter.name)) {
+          // eslint-disable-next-line prefer-destructuring
+          filterName = options.filter.name;
+        } else {
+          filterName = [options.filter.name];
+        }
+      }
+
+      // TODO - get sort and order working
+      /*
+      if (options && options.sort) {
+        reqObj.uriOptions.sort = JSON.stringify(options.sort);
+      }
+      if (options && options.order) {
+        reqObj.uriOptions.order = options.order;
+      }
+      */
+      const callPromises = [];
+      for (let i = 0; i < this.allProps.devicebroker.getDevicesFiltered.length; i += 1) {
+        // Perform component calls here.
+        callPromises.push(
+          new Promise((resolve, reject) => {
+            this.iapMakeBrokerCall('getDevicesFiltered', this.allProps.devicebroker.getDevicesFiltered[i], [{ fake: 'fakedata' }], filterName, (callRet, callErr) => {
+              // return an error
+              if (callErr) {
+                reject(callErr);
+              } else {
+                // return the data
+                resolve(callRet);
+              }
+            });
+          })
+        );
+      }
+
+      // return an array of repsonses
+      return Promise.all(callPromises).then((results) => {
+        let myResult = [];
+        results.forEach((result) => {
+          if (Array.isArray(result)) {
+            myResult = [...myResult, ...result];
+          } else if (Object.keys(result).length > 0) {
+            myResult.push(result);
+          }
+        });
+
+        log.debug(`${origin}: Found #${myResult.length} devices.`);
+        log.debug(`Devices: ${JSON.stringify(myResult)}`);
+        return callback({ total: myResult.length, list: myResult });
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Gets the status for the provided appliance
+   *
+   * @function isAlive
+   * @param {String} deviceName - the deviceName of the appliance. (required)
+   *
+   * @param {configCallback} callback - callback function to return the result
+   *                                    (appliance isAlive) or the error
+   */
+  isAlive(deviceName, callback) {
+    const meth = 'adapterBase-isAlive';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker isAlive
+    if (!this.allProps.devicebroker || !this.allProps.devicebroker.isAlive || this.allProps.devicebroker.isAlive.length === 0 || !this.allProps.devicebroker.isAlive[0].path) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Properties', ['devicebroker.isAlive.path'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    // verify the required fields have been provided
+    if (deviceName === undefined || deviceName === null || deviceName === '' || deviceName.length === 0) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['deviceName'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    try {
+      // need to get the device so we can convert the deviceName to an id
+      // !! if we can do a lookup by name the getDevicesFiltered may not be necessary
+      const opts = {
+        filter: {
+          name: deviceName
+        }
+      };
+      return this.getDevicesFiltered(opts, (devs, ferr) => {
+        // if we received an error or their is no response on the results return an error
+        if (ferr) {
+          return callback(null, ferr);
+        }
+        if (devs.list.length < 1) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Did Not Find Device ${deviceName}`, [], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        const callPromises = [];
+        for (let i = 0; i < this.allProps.devicebroker.isAlive.length; i += 1) {
+          // Perform component calls here.
+          callPromises.push(
+            new Promise((resolve, reject) => {
+              this.iapMakeBrokerCall('isAlive', this.allProps.devicebroker.isAlive[i], [devs.list[0]], null, (callRet, callErr) => {
+                // return an error
+                if (callErr) {
+                  reject(callErr);
+                } else {
+                  // return the data
+                  resolve(callRet);
+                }
+              });
+            })
+          );
+        }
+
+        // return an array of repsonses
+        return Promise.all(callPromises).then((results) => {
+          let myResult = {};
+          results.forEach((result) => {
+            myResult = { ...myResult, ...result };
+          });
+
+          let response = true;
+          if (myResult.isAlive !== null && myResult.isAlive !== undefined && myResult.isAlive === false) {
+            response = false;
+          }
+          return callback(response);
+        });
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Gets a config for the provided Appliance
+   *
+   * @function getConfig
+   * @param {String} deviceName - the deviceName of the appliance. (required)
+   * @param {String} format - the desired format of the config. (optional)
+   *
+   * @param {configCallback} callback - callback function to return the result
+   *                                    (appliance config) or the error
+   */
+  getConfig(deviceName, format, callback) {
+    const meth = 'adapterBase-getConfig';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker getConfig
+    if (!this.allProps.devicebroker || !this.allProps.devicebroker.getConfig || this.allProps.devicebroker.getConfig.length === 0 || !this.allProps.devicebroker.getConfig[0].path) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Properties', ['devicebroker.getConfig.path'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    // verify the required fields have been provided
+    if (deviceName === undefined || deviceName === null || deviceName === '' || deviceName.length === 0) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['deviceName'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    try {
+      // need to get the device so we can convert the deviceName to an id
+      // !! if we can do a lookup by name the getDevicesFiltered may not be necessary
+      const opts = {
+        filter: {
+          name: deviceName
+        }
+      };
+      return this.getDevicesFiltered(opts, (devs, ferr) => {
+        // if we received an error or their is no response on the results return an error
+        if (ferr) {
+          return callback(null, ferr);
+        }
+        if (devs.list.length < 1) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, `Did Not Find Device ${deviceName}`, [], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        const callPromises = [];
+        for (let i = 0; i < this.allProps.devicebroker.getConfig.length; i += 1) {
+          // Perform component calls here.
+          callPromises.push(
+            new Promise((resolve, reject) => {
+              this.iapMakeBrokerCall('getConfig', this.allProps.devicebroker.getConfig[i], [devs.list[0]], null, (callRet, callErr) => {
+                // return an error
+                if (callErr) {
+                  reject(callErr);
+                } else {
+                  // return the data
+                  resolve(callRet);
+                }
+              });
+            })
+          );
+        }
+
+        // return an array of repsonses
+        return Promise.all(callPromises).then((results) => {
+          let myResult = {};
+          results.forEach((result) => {
+            myResult = { ...myResult, ...result };
+          });
+
+          // return the result
+          const newResponse = {
+            response: JSON.stringify(myResult, null, 2)
+          };
+          return callback(newResponse, null);
+        });
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Gets the device count from the system
+   *
+   * @function iapGetDeviceCount
+   *
+   * @param {getCallback} callback - callback function to return the result
+   *                                    (count) or the error
+   */
+  iapGetDeviceCount(callback) {
+    const meth = 'adapterBase-iapGetDeviceCount';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker getCount
+    if (!this.allProps.devicebroker || !this.allProps.devicebroker.getCount || this.allProps.devicebroker.getCount.length === 0 || !this.allProps.devicebroker.getCount[0].path) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Properties', ['devicebroker.getCount.path'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+
+    // verify the required fields have been provided
+
+    try {
+      const callPromises = [];
+      for (let i = 0; i < this.allProps.devicebroker.getCount.length; i += 1) {
+        // Perform component calls here.
+        callPromises.push(
+          new Promise((resolve, reject) => {
+            this.iapMakeBrokerCall('getCount', this.allProps.devicebroker.getCount[i], null, null, (callRet, callErr) => {
+              // return an error
+              if (callErr) {
+                reject(callErr);
+              } else {
+                // return the data
+                resolve(callRet);
+              }
+            });
+          })
+        );
+      }
+
+      // return an array of repsonses
+      return Promise.all(callPromises).then((results) => {
+        let myResult = {};
+        results.forEach((result) => {
+          myResult = { ...myResult, ...result };
+        });
+
+        // return the result
+        return callback({ count: myResult.length });
+      });
+    } catch (ex) {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
 }
 
 module.exports = AdapterBase;