@itentialopensource/adapter-meraki 0.7.2 → 0.8.1

package/adapter.js

@@ -2,8 +2,6 @@
 
 /* eslint import/no-dynamic-require: warn */
 /* eslint object-curly-newline: warn */
-/* eslint no-underscore-dangle: warn  */
-/* eslint camelcase: warn  */
 
 // Set globals
 /* global log */
@@ -82,10 +80,10 @@ class Meraki extends AdapterBaseCl {
   }
 
   /**
-   * @getWorkflowFunctions
+   * @iapGetAdapterWorkflowFunctions
    */
-  getWorkflowFunctions(inIgnore) {
-    let myIgnore = [];
+  iapGetAdapterWorkflowFunctions(inIgnore) {
+    let myIgnore = ['hasEntities', 'hasDevices'];
     if (!inIgnore && Array.isArray(inIgnore)) {
       myIgnore = inIgnore;
     } else if (!inIgnore && typeof inIgnore === 'string') {
@@ -96,15 +94,15 @@ class Meraki extends AdapterBaseCl {
     // you can add specific methods that you do not want to be workflow functions to ignore like below
     // myIgnore.push('myMethodNotInWorkflow');
 
-    return super.getWorkflowFunctions(myIgnore);
+    return super.iapGetAdapterWorkflowFunctions(myIgnore);
   }
 
   /**
-   * updateAdapterConfiguration is used to update any of the adapter configuration files. This
+   * 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 updateAdapterConfiguration
+   * @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)
@@ -112,36 +110,36 @@ class Meraki extends AdapterBaseCl {
    * @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 origin = `${this.id}-adapter-updateAdapterConfiguration`;
+  iapUpdateAdapterConfiguration(configFile, changes, entity, type, action, callback) {
+    const origin = `${this.id}-adapter-iapUpdateAdapterConfiguration`;
     log.trace(origin);
-    super.updateAdapterConfiguration(configFile, changes, entity, type, action, callback);
+    super.iapUpdateAdapterConfiguration(configFile, changes, entity, type, action, callback);
   }
 
   /**
    * 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) {
-    const origin = `${this.id}-adapter-findPath`;
+  iapFindAdapterPath(apiPath, callback) {
+    const origin = `${this.id}-adapter-iapFindAdapterPath`;
     log.trace(origin);
-    super.findPath(apiPath, callback);
+    super.iapFindAdapterPath(apiPath, callback);
   }
 
   /**
     * @summary Suspends adapter
     *
-    * @function suspend
+    * @function iapSuspendAdapter
     * @param {Callback} callback - callback function
     */
-  suspend(mode, callback) {
-    const origin = `${this.id}-adapter-suspend`;
+  iapSuspendAdapter(mode, callback) {
+    const origin = `${this.id}-adapter-iapSuspendAdapter`;
     log.trace(origin);
     try {
-      return super.suspend(mode, callback);
+      return super.iapSuspendAdapter(mode, callback);
     } catch (error) {
       log.error(`${origin}: ${error}`);
       return callback(null, error);
@@ -151,14 +149,14 @@ class Meraki extends AdapterBaseCl {
   /**
     * @summary Unsuspends adapter
     *
-    * @function unsuspend
+    * @function iapUnsuspendAdapter
     * @param {Callback} callback - callback function
     */
-  unsuspend(callback) {
-    const origin = `${this.id}-adapter-unsuspend`;
+  iapUnsuspendAdapter(callback) {
+    const origin = `${this.id}-adapter-iapUnsuspendAdapter`;
     log.trace(origin);
     try {
-      return super.unsuspend(callback);
+      return super.iapUnsuspendAdapter(callback);
     } catch (error) {
       log.error(`${origin}: ${error}`);
       return callback(null, error);
@@ -168,29 +166,29 @@ class Meraki extends AdapterBaseCl {
   /**
     * @summary Get the Adaoter Queue
     *
-    * @function getQueue
+    * @function iapGetAdapterQueue
     * @param {Callback} callback - callback function
     */
-  getQueue(callback) {
-    const origin = `${this.id}-adapter-getQueue`;
+  iapGetAdapterQueue(callback) {
+    const origin = `${this.id}-adapter-iapGetAdapterQueue`;
     log.trace(origin);
-    return super.getQueue(callback);
+    return super.iapGetAdapterQueue(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 {Callback} callback - The results of the call
   */
-  troubleshoot(props, persistFlag, callback) {
-    const origin = `${this.id}-adapter-troubleshoot`;
+  iapTroubleshootAdapter(props, persistFlag, callback) {
+    const origin = `${this.id}-adapter-iapTroubleshootAdapter`;
     log.trace(origin);
     try {
-      return super.troubleshoot(props, persistFlag, this, callback);
+      return super.iapTroubleshootAdapter(props, persistFlag, this, callback);
     } catch (error) {
       log.error(`${origin}: ${error}`);
       return callback(null, error);
@@ -200,15 +198,15 @@ class Meraki extends AdapterBaseCl {
   /**
     * @summary runs healthcheck script for adapter
     *
-    * @function runHealthcheck
+    * @function iapRunAdapterHealthcheck
     * @param {Adapter} adapter - adapter instance to troubleshoot
     * @param {Callback} callback - callback function
     */
-  runHealthcheck(callback) {
-    const origin = `${this.id}-adapter-runHealthcheck`;
+  iapRunAdapterHealthcheck(callback) {
+    const origin = `${this.id}-adapter-iapRunAdapterHealthcheck`;
     log.trace(origin);
     try {
-      return super.runHealthcheck(this, callback);
+      return super.iapRunAdapterHealthcheck(this, callback);
     } catch (error) {
       log.error(`${origin}: ${error}`);
       return callback(null, error);
@@ -218,14 +216,14 @@ class Meraki extends AdapterBaseCl {
   /**
     * @summary runs connectivity check script for adapter
     *
-    * @function runConnectivity
+    * @function iapRunAdapterConnectivity
     * @param {Callback} callback - callback function
     */
-  runConnectivity(callback) {
-    const origin = `${this.id}-adapter-runConnectivity`;
+  iapRunAdapterConnectivity(callback) {
+    const origin = `${this.id}-adapter-iapRunAdapterConnectivity`;
     log.trace(origin);
     try {
-      return super.runConnectivity(callback);
+      return super.iapRunAdapterConnectivity(callback);
     } catch (error) {
       log.error(`${origin}: ${error}`);
       return callback(null, error);
@@ -235,44 +233,63 @@ class Meraki extends AdapterBaseCl {
   /**
     * @summary runs basicGet script for adapter
     *
-    * @function runBasicGet
+    * @function iapRunAdapterBasicGet
     * @param {Callback} callback - callback function
     */
-  runBasicGet(callback) {
-    const origin = `${this.id}-adapter-runBasicGet`;
+  iapRunAdapterBasicGet(callback) {
+    const origin = `${this.id}-adapter-iapRunAdapterBasicGet`;
     log.trace(origin);
     try {
-      return super.runBasicGet(callback);
+      return super.iapRunAdapterBasicGet(callback);
     } catch (error) {
       log.error(`${origin}: ${error}`);
       return callback(null, error);
     }
   }
 
+  /**
+   * @summary moves entites into Mongo DB
+   *
+   * @function iapMoveAdapterEntitiesToDB
+   * @param {getCallback} callback - a callback function to return the result (Generics)
+   *                                  or the error
+   */
+  iapMoveAdapterEntitiesToDB(callback) {
+    const origin = `${this.id}-adapter-iapMoveAdapterEntitiesToDB`;
+    log.trace(origin);
+    try {
+      return super.iapMoveAdapterEntitiesToDB(callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
+  /* BROKER CALLS */
   /**
    * @summary Determines if this adapter supports the specific entity
    *
-   * @function hasEntity
+   * @function iapHasAdapterEntity
    * @param {String} entityType - the entity type to check for
    * @param {String/Array} entityId - the specific entity we are looking for
    *
    * @param {Callback} callback - An array of whether the adapter can has the
    *                              desired capability or an error
    */
-  hasEntity(entityType, entityId, callback) {
-    const origin = `${this.id}-adapter-hasEntity`;
+  iapHasAdapterEntity(entityType, entityId, callback) {
+    const origin = `${this.id}-adapter-iapHasAdapterEntity`;
     log.trace(origin);
 
     // Make the call -
-    // verifyCapability(entityType, actionType, entityId, callback)
-    return this.verifyCapability(entityType, null, entityId, callback);
+    // iapVerifyAdapterCapability(entityType, actionType, entityId, callback)
+    return this.iapVerifyAdapterCapability(entityType, null, entityId, callback);
   }
 
   /**
    * @summary Provides a way for the adapter to tell north bound integrations
    * whether the adapter supports type, action and specific entity
    *
-   * @function verifyCapability
+   * @function iapVerifyAdapterCapability
    * @param {String} entityType - the entity type to check for
    * @param {String} actionType - the action type to check for
    * @param {String/Array} entityId - the specific entity we are looking for
@@ -280,15 +297,15 @@ class Meraki extends AdapterBaseCl {
    * @param {Callback} callback - An array of whether the adapter can has the
    *                              desired capability or an error
    */
-  verifyCapability(entityType, actionType, entityId, callback) {
-    const meth = 'adapterBase-verifyCapability';
+  iapVerifyAdapterCapability(entityType, actionType, entityId, callback) {
+    const meth = 'adapterBase-iapVerifyAdapterCapability';
     const origin = `${this.id}-${meth}`;
     log.trace(origin);
 
     // if caching
     if (this.caching) {
-      // Make the call - verifyCapability(entityType, actionType, entityId, callback)
-      return this.requestHandlerInst.verifyCapability(entityType, actionType, entityId, (results, error) => {
+      // Make the call - iapVerifyAdapterCapability(entityType, actionType, entityId, callback)
+      return this.requestHandlerInst.iapVerifyAdapterCapability(entityType, actionType, entityId, (results, error) => {
         if (error) {
           return callback(null, error);
         }
@@ -306,7 +323,7 @@ class Meraki extends AdapterBaseCl {
                 }
 
                 // need to check the cache again since it has been updated
-                return this.requestHandlerInst.verifyCapability(entityType, actionType, entityId, (vcapable, verror) => {
+                return this.requestHandlerInst.iapVerifyAdapterCapability(entityType, actionType, entityId, (vcapable, verror) => {
                   if (verror) {
                     return callback(null, verror);
                   }
@@ -339,7 +356,7 @@ class Meraki extends AdapterBaseCl {
     // if no entity id
     if (!entityId) {
       // need to check the cache again since it has been updated
-      return this.requestHandlerInst.verifyCapability(entityType, actionType, null, (vcapable, verror) => {
+      return this.requestHandlerInst.iapVerifyAdapterCapability(entityType, actionType, null, (vcapable, verror) => {
         if (verror) {
           return callback(null, verror);
         }
@@ -360,7 +377,7 @@ class Meraki extends AdapterBaseCl {
           }
 
           // need to check the cache again since it has been updated
-          return this.requestHandlerInst.verifyCapability(entityType, actionType, null, (vcapable, verror) => {
+          return this.requestHandlerInst.iapVerifyAdapterCapability(entityType, actionType, null, (vcapable, verror) => {
             if (verror) {
               return callback(null, verror);
             }
@@ -401,11 +418,11 @@ class Meraki extends AdapterBaseCl {
   /**
    * @summary Updates the cache for all entities by call the get All entity method
    *
-   * @function updateEntityCache
+   * @function iapUpdateAdapterEntityCache
    *
    */
-  updateEntityCache() {
-    const origin = `${this.id}-adapter-updateEntityCache`;
+  iapUpdateAdapterEntityCache() {
+    const origin = `${this.id}-adapter-iapUpdateAdapterEntityCache`;
     log.trace(origin);
 
     if (this.caching) {
@@ -418,6 +435,836 @@ class Meraki extends AdapterBaseCl {
     }
   }
 
+  /**
+   * @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 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 = 'adapter-getDevice';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker getDevice
+    if (!this.props.devicebroker || !this.props.devicebroker.getDevice || !this.props.devicebroker.getDevice.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);
+        }
+        // get the uuid from the device
+        const { uuid } = devs.list[0];
+
+        // !! 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
+        let uriPath = '';
+        let uriMethod = 'GET';
+        let callQuery = {};
+        let callBody = {};
+        let callHeaders = {};
+        let nameField = 'name';
+        let nameArray = ['name'];
+        let ostypeField = 'ostype';
+        let ostypeArray = ['ostype'];
+        let ostypePrefix = '';
+        let portField = 'port';
+        let portArray = ['port'];
+        let ipField = 'ipaddress';
+        let ipArray = ['ipaddress'];
+        if (this.props.devicebroker.getDevice.path) {
+          uriPath = `${this.props.devicebroker.getDevice.path}`;
+          uriPath = uriPath.replace('{deviceid}', uuid);
+        }
+        if (this.props.devicebroker.getDevice.method) {
+          uriMethod = this.props.devicebroker.getDevice.method;
+        }
+        if (this.props.devicebroker.getDevice.query) {
+          try {
+            callQuery = JSON.parse(this.props.devicebroker.getDevice.query);
+          } catch (e) {
+            log.warn('Could not parse query parameter for getDevice call');
+          }
+        }
+        if (this.props.devicebroker.getDevice.body) {
+          try {
+            callBody = this.props.devicebroker.getDevice.body;
+          } catch (e) {
+            log.warn('Could not parse body for getDevice call');
+          }
+        }
+        if (this.props.devicebroker.getDevice.headers) {
+          try {
+            callHeaders = this.props.devicebroker.getDevice.headers;
+          } catch (e) {
+            log.warn('Could not parse headers for getDevice call');
+          }
+        }
+        if (this.props.devicebroker.getDevice.name_field) {
+          nameField = this.props.devicebroker.getDevice.name_field;
+          nameArray = nameField.split('.');
+        }
+        if (this.props.devicebroker.getDevice.ostype_field) {
+          ostypeField = this.props.devicebroker.getDevice.ostype_field;
+          ostypeArray = ostypeField.split('.');
+        }
+        if (this.props.devicebroker.getDevice.ostype_prefix) {
+          ostypePrefix = this.props.devicebroker.getDevice.ostype_prefix;
+        }
+        if (this.props.devicebroker.getDevice.port_field) {
+          portField = this.props.devicebroker.getDevice.port_field;
+          portArray = portField.split('.');
+        }
+        if (this.props.devicebroker.getDevice.ip_field) {
+          ipField = this.props.devicebroker.getDevice.ip_field;
+          ipArray = ipField.split('.');
+        }
+
+        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) {
+            return callback(null, error);
+          }
+          if (!result.response) {
+            const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevice'], null, null, null);
+            log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+            return callback(null, errorObj);
+          }
+
+          // return the response
+          // !! format the data we send back
+          // !! these fields are config manager fields you need to map to the data we receive
+          const thisDevice = result.response;
+          let thisName = thisDevice;
+          for (let i = 0; i < nameArray.length; i += 1) {
+            if (!Object.hasOwnProperty.call(thisName, nameArray[i])) {
+              const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+              log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+              return callback(null, errorObj);
+            }
+            thisName = thisName[nameArray[i]];
+          }
+          thisDevice.name = thisName;
+          let thisOstype = thisDevice;
+          for (let i = 0; i < ostypeArray.length; i += 1) {
+            if (!Object.hasOwnProperty.call(thisOstype, ostypeArray[i])) {
+              const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+              log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+              return callback(null, errorObj);
+            }
+            thisOstype = thisOstype[ostypeArray[i]];
+          }
+          thisDevice.ostype = ostypePrefix + thisOstype;
+          let thisPort = thisDevice;
+          for (let i = 0; i < portArray.length; i += 1) {
+            if (!Object.hasOwnProperty.call(thisPort, portArray[i])) {
+              const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+              log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+              return callback(null, errorObj);
+            }
+            thisPort = thisPort[portArray[i]];
+          }
+          thisDevice.port = thisPort;
+          let thisIp = thisDevice;
+          for (let i = 0; i < ipArray.length; i += 1) {
+            if (!Object.hasOwnProperty.call(thisIp, ipArray[i])) {
+              const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+              log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+              return callback(null, errorObj);
+            }
+            thisIp = thisIp[ipArray[i]];
+          }
+          thisDevice.ipaddress = thisIp;
+          return callback(thisDevice);
+        });
+      });
+    } 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 = 'adapter-getDevicesFiltered';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker getDevicesFiltered
+    if (!this.props.devicebroker || !this.props.devicebroker.getDevicesFiltered || !this.props.devicebroker.getDevicesFiltered.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)}`);
+
+    // 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;
+    }
+    */
+    try {
+      // !! 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
+      let uriPath = '';
+      let uriMethod = 'GET';
+      let callQuery = {};
+      let callBody = {};
+      let callHeaders = {};
+      let nameField = 'name';
+      let nameArray = ['name'];
+      let ostypeField = 'ostype';
+      let ostypeArray = ['ostype'];
+      let ostypePrefix = '';
+      let portField = 'port';
+      let portArray = ['port'];
+      let ipField = 'ipaddress';
+      let ipArray = ['ipaddress'];
+      if (this.props.devicebroker.getDevicesFiltered.path) {
+        uriPath = this.props.devicebroker.getDevicesFiltered.path;
+      }
+      if (this.props.devicebroker.getDevicesFiltered.method) {
+        uriMethod = this.props.devicebroker.getDevicesFiltered.method;
+      }
+      if (this.props.devicebroker.getDevicesFiltered.query) {
+        try {
+          callQuery = this.props.devicebroker.getDevicesFiltered.query;
+        } catch (e) {
+          log.warn('Could not parse query parameter for getDevicesFiltered call');
+        }
+      }
+      if (this.props.devicebroker.getDevicesFiltered.body) {
+        try {
+          callBody = this.props.devicebroker.getDevicesFiltered.body;
+        } catch (e) {
+          log.warn('Could not parse body for getDevicesFiltered call');
+        }
+      }
+      if (this.props.devicebroker.getDevicesFiltered.headers) {
+        try {
+          callHeaders = this.props.devicebroker.getDevicesFiltered.headers;
+        } catch (e) {
+          log.warn('Could not parse headers for getDevicesFiltered call');
+        }
+      }
+      if (this.props.devicebroker.getDevicesFiltered.name_field) {
+        nameField = this.props.devicebroker.getDevicesFiltered.name_field;
+        nameArray = nameField.split('.');
+      }
+      if (this.props.devicebroker.getDevicesFiltered.ostype_field) {
+        ostypeField = this.props.devicebroker.getDevicesFiltered.ostype_field;
+        ostypeArray = ostypeField.split('.');
+      }
+      if (this.props.devicebroker.getDevicesFiltered.ostype_prefix) {
+        ostypePrefix = this.props.devicebroker.getDevicesFiltered.ostype_prefix;
+      }
+      if (this.props.devicebroker.getDevicesFiltered.port_field) {
+        portField = this.props.devicebroker.getDevicesFiltered.port_field;
+        portArray = portField.split('.');
+      }
+      if (this.props.devicebroker.getDevicesFiltered.ip_field) {
+        ipField = this.props.devicebroker.getDevicesFiltered.ip_field;
+        ipArray = ipField.split('.');
+      }
+
+      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) {
+          return callback(null, error);
+        }
+        if (!result.response) {
+          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+          return callback(null, errorObj);
+        }
+
+        // !! go through the response - may have to look for sub object
+        // handle an array of devices
+        if (Array.isArray(result.response)) {
+          const myDevices = [];
+
+          for (let d = 0; d < result.response.length; d += 1) {
+            // !! format the data we send back
+            // !! these fields are config manager fields you need to map to the data we receive
+            const thisDevice = result.response;
+            let thisName = thisDevice;
+            for (let i = 0; i < nameArray.length; i += 1) {
+              if (!Object.hasOwnProperty.call(thisName, nameArray[i])) {
+                const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+                log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+                return callback(null, errorObj);
+              }
+              thisName = thisName[nameArray[i]];
+            }
+            thisDevice.name = thisName;
+            let thisOstype = thisDevice;
+            for (let i = 0; i < ostypeArray.length; i += 1) {
+              if (!Object.hasOwnProperty.call(thisOstype, ostypeArray[i])) {
+                const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+                log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+                return callback(null, errorObj);
+              }
+              thisOstype = thisOstype[ostypeArray[i]];
+            }
+            thisDevice.ostype = ostypePrefix + thisOstype;
+            let thisPort = thisDevice;
+            for (let i = 0; i < portArray.length; i += 1) {
+              if (!Object.hasOwnProperty.call(thisPort, portArray[i])) {
+                const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+                log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+                return callback(null, errorObj);
+              }
+              thisPort = thisPort[portArray[i]];
+            }
+            thisDevice.port = thisPort;
+            let thisIp = thisDevice;
+            for (let i = 0; i < ipArray.length; i += 1) {
+              if (!Object.hasOwnProperty.call(thisIp, ipArray[i])) {
+                const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+                log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+                return callback(null, errorObj);
+              }
+              thisIp = thisIp[ipArray[i]];
+            }
+            thisDevice.ipaddress = thisIp;
+
+            // if there is no filter - return the device
+            if (filterName.length === 0) {
+              myDevices.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) {
+                myDevices.push(thisDevice);
+              }
+            }
+          }
+          log.debug(`${origin}: Found #${myDevices.length} devices.`);
+          log.debug(`Devices: ${JSON.stringify(myDevices)}`);
+          return callback({ total: myDevices.length, list: myDevices });
+        }
+        // handle a single device response
+        // !! format the data we send back
+        // !! these fields are config manager fields you need to map to the data we receive
+        const thisDevice = result.response;
+        let thisName = thisDevice;
+        for (let i = 0; i < nameArray.length; i += 1) {
+          if (!Object.hasOwnProperty.call(thisName, nameArray[i])) {
+            const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+            log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+            return callback(null, errorObj);
+          }
+          thisName = thisName[nameArray[i]];
+        }
+        thisDevice.name = thisName;
+        let thisOstype = thisDevice;
+        for (let i = 0; i < ostypeArray.length; i += 1) {
+          if (!Object.hasOwnProperty.call(thisOstype, ostypeArray[i])) {
+            const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+            log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+            return callback(null, errorObj);
+          }
+          thisOstype = thisOstype[ostypeArray[i]];
+        }
+        thisDevice.ostype = ostypePrefix + thisOstype;
+        let thisPort = thisDevice;
+        for (let i = 0; i < portArray.length; i += 1) {
+          if (!Object.hasOwnProperty.call(thisPort, portArray[i])) {
+            const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+            log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+            return callback(null, errorObj);
+          }
+          thisPort = thisPort[portArray[i]];
+        }
+        thisDevice.port = thisPort;
+        let thisIp = thisDevice;
+        for (let i = 0; i < ipArray.length; i += 1) {
+          if (!Object.hasOwnProperty.call(thisIp, ipArray[i])) {
+            const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['getDevicesFiltered'], null, null, null);
+            log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+            return callback(null, errorObj);
+          }
+          thisIp = thisIp[ipArray[i]];
+        }
+        thisDevice.ipaddress = thisIp;
+
+        // if there is no filter - return the device
+        if (filterName.length === 0) {
+          log.debug(`${origin}: Found #1 device.`);
+          log.debug(`Device: ${JSON.stringify(thisDevice)}`);
+          return callback({ total: 1, list: [thisDevice] });
+        }
+
+        // if there is a filter need to check for matching device
+        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) {
+          log.debug(`${origin}: Found #1 device.`);
+          log.debug(`Device Found: ${JSON.stringify(thisDevice)}`);
+          return callback({ total: 1, list: [thisDevice] });
+        }
+        // not a matching device
+        log.debug(`${origin}: No matching device found.`);
+        return callback({ total: 0, list: [] });
+      });
+    } 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 = 'adapter-isAlive';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker isAlive
+    if (!this.props.devicebroker || !this.props.devicebroker.isAlive || !this.props.devicebroker.isAlive.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);
+        }
+        // get the uuid from the device
+        const { uuid } = devs.list[0];
+
+        // !! 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
+        let uriPath = '';
+        let uriMethod = 'GET';
+        let callQuery = {};
+        let callBody = {};
+        let callHeaders = {};
+        let statusField = 'status';
+        let statusArray = ['status'];
+        let statusValue = 'true';
+        if (this.props.devicebroker.isAlive.path) {
+          uriPath = `${this.props.devicebroker.isAlive.path}`;
+          uriPath = uriPath.replace('{deviceid}', uuid);
+        }
+        if (this.props.devicebroker.isAlive.method) {
+          uriMethod = this.props.devicebroker.isAlive.method;
+        }
+        if (this.props.devicebroker.isAlive.query) {
+          try {
+            callQuery = this.props.devicebroker.isAlive.query;
+          } catch (e) {
+            log.warn('Could not parse query parameter for isAlive call');
+          }
+        }
+        if (this.props.devicebroker.isAlive.body) {
+          try {
+            callBody = this.props.devicebroker.isAlive.body;
+          } catch (e) {
+            log.warn('Could not parse body for isAlive call');
+          }
+        }
+        if (this.props.devicebroker.isAlive.headers) {
+          try {
+            callHeaders = this.props.devicebroker.isAlive.headers;
+          } catch (e) {
+            log.warn('Could not parse headers for isAlive call');
+          }
+        }
+        if (this.props.devicebroker.isAlive.response && this.props.devicebroker.isAlive.status_field) {
+          statusField = this.props.devicebroker.isAlive.status_field;
+          statusArray = statusField.split('.');
+        }
+        if (this.props.devicebroker.isAlive.response && this.props.devicebroker.isAlive.status_value) {
+          statusValue = this.props.devicebroker.isAlive.response.status_value;
+        }
+
+        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) {
+            return callback(null, error);
+          }
+
+          // !! should update this to make sure we are checking for the appropriate object/field
+          if (!result.response || !result.response.returnObj) {
+            const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['isAlive'], null, null, null);
+            log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+            return callback(null, errorObj);
+          }
+          let thisObj = result.response.returnObj;
+          for (let i = 0; i < statusArray.length; i += 1) {
+            if (!Object.hasOwnProperty.call(thisObj, statusArray[i])) {
+              const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['isAlive'], null, null, null);
+              log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+              return callback(null, errorObj);
+            }
+            thisObj = thisObj[statusArray[i]];
+          }
+
+          // !! return the response - Update to the appropriate object/field
+          let response = true;
+          if (thisObj.toString() !== statusValue) {
+            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 = 'adapter-getConfig';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker getConfig
+    if (!this.props.devicebroker || !this.props.devicebroker.getConfig || !this.props.devicebroker.getConfig.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);
+        }
+        // get the uuid from the device
+        const { uuid } = devs.list[0];
+
+        // !! 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
+        let uriPath = '';
+        let uriMethod = 'GET';
+        let callQuery = {};
+        let callBody = {};
+        let callHeaders = {};
+        if (this.props.devicebroker.getConfig.path) {
+          uriPath = `${this.props.devicebroker.getConfig.path}`;
+          uriPath = uriPath.replace('{deviceid}', uuid);
+        }
+        if (this.props.devicebroker.getConfig.method) {
+          uriMethod = this.props.devicebroker.getConfig.method;
+        }
+        if (this.props.devicebroker.getConfig.query) {
+          try {
+            callQuery = this.props.devicebroker.getConfig.query;
+          } catch (e) {
+            log.warn('Could not parse query parameter for getConfig call');
+          }
+        }
+        if (this.props.devicebroker.getConfig.body) {
+          try {
+            callBody = this.props.devicebroker.getConfig.body;
+          } catch (e) {
+            log.warn('Could not parse body for getConfig call');
+          }
+        }
+        if (this.props.devicebroker.getConfig.headers) {
+          try {
+            callHeaders = this.props.devicebroker.getConfig.headers;
+          } catch (e) {
+            log.warn('Could not parse headers for getConfig call');
+          }
+        }
+
+        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) {
+            return callback(null, error);
+          }
+
+          // return the result
+          const newResponse = {
+            response: JSON.stringify(result.response, null, 2)
+          };
+          return callback(newResponse);
+        });
+      });
+    } 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 = 'adapter-iapGetDeviceCount';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // make sure we are set up for device broker getCount
+    if (!this.props.devicebroker || !this.props.devicebroker.getCount || !this.props.devicebroker.getCount.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 {
+      // !! using Generic makes it easier on the Adapter Builder (just need to set the path or call in properties)
+      // !! you can also replace with a specific call if that is easier
+      let uriPath = '';
+      let uriMethod = 'GET';
+      let callQuery = {};
+      let callBody = {};
+      let callHeaders = {};
+      if (this.props.devicebroker.getCount.path) {
+        uriPath = this.props.devicebroker.getCount.path;
+      }
+      if (this.props.devicebroker.getCount.method) {
+        uriMethod = this.props.devicebroker.getCount.method;
+      }
+      if (this.props.devicebroker.getCount.query) {
+        try {
+          callQuery = this.props.devicebroker.getCount.query;
+        } catch (e) {
+          log.warn('Could not parse query parameter for getCount call');
+        }
+      }
+      if (this.props.devicebroker.getCount.body) {
+        try {
+          callBody = this.props.devicebroker.getCount.body;
+        } catch (e) {
+          log.warn('Could not parse body for getCount call');
+        }
+      }
+      if (this.props.devicebroker.getCount.headers) {
+        try {
+          callHeaders = this.props.devicebroker.getCount.headers;
+        } catch (e) {
+          log.warn('Could not parse headers for getCount call');
+        }
+      }
+
+      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) {
+          return callback(null, error);
+        }
+
+        // return the result
+        return callback({ count: result.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);
+    }
+  }
+
+  /* GENERIC ADAPTER REQUEST - allows extension of adapter without new calls being added */
   /**
    * Makes the requested generic call
    *
@@ -22405,7 +23252,7 @@ class Meraki extends AdapterBaseCl {
     const queryParamsAvailable = {};
     const queryParams = {};
     const pathVars = [organizationId, licenseId];
-    const bodyVars = { body };
+    const bodyVars = body;
 
     // loop in template. long callback arg name to avoid identifier conflicts
     Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
@@ -22480,7 +23327,7 @@ class Meraki extends AdapterBaseCl {
     const queryParamsAvailable = {};
     const queryParams = {};
     const pathVars = [organizationId];
-    const bodyVars = { body };
+    const bodyVars = body;
 
     // loop in template. long callback arg name to avoid identifier conflicts
     Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
@@ -22555,7 +23402,7 @@ class Meraki extends AdapterBaseCl {
     const queryParamsAvailable = {};
     const queryParams = {};
     const pathVars = [organizationId];
-    const bodyVars = { body };
+    const bodyVars = body;
 
     // loop in template. long callback arg name to avoid identifier conflicts
     Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
@@ -22630,7 +23477,7 @@ class Meraki extends AdapterBaseCl {
     const queryParamsAvailable = {};
     const queryParams = {};
     const pathVars = [organizationId];
-    const bodyVars = { body };
+    const bodyVars = body;
 
     // loop in template. long callback arg name to avoid identifier conflicts
     Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
@@ -22705,7 +23552,7 @@ class Meraki extends AdapterBaseCl {
     const queryParamsAvailable = {};
     const queryParams = {};
     const pathVars = [organizationId];
-    const bodyVars = { body };
+    const bodyVars = body;
 
     // loop in template. long callback arg name to avoid identifier conflicts
     Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {