@itentialopensource/adapter-zscaler 0.6.6 → 0.6.7

package/CHANGELOG.md

@@ -1,4 +1,12 @@
 
+## 0.6.7 [01-19-2022]
+
+* Changed health check url
+
+See merge request itentialopensource/adapters/security/adapter-zscaler!12
+
+---
+
 ## 0.6.6 [11-17-2021]
 
 * fix lint errors after updating adapter.js and pronghorn.json

package/adapter.js

@@ -85,7 +85,7 @@ class Zscaler extends AdapterBaseCl {
    * @getWorkflowFunctions
    */
   getWorkflowFunctions(inIgnore) {
-    let myIgnore = ['getObfuscatedKey'];
+    let myIgnore = ['hasEntities', 'hasDevices', 'getObfuscatedKey'];
     if (!inIgnore && Array.isArray(inIgnore)) {
       myIgnore = inIgnore;
     } else if (!inIgnore && typeof inIgnore === 'string') {
@@ -249,6 +249,24 @@ class Zscaler extends AdapterBaseCl {
     }
   }
 
+  /**
+   * @summary moves entites into Mongo DB
+   *
+   * @function moveEntitiesToDB
+   * @param {getCallback} callback - a callback function to return the result (Generics)
+   *                                  or the error
+   */
+  moveEntitiesToDB(callback) {
+    const origin = `${this.id}-adapter-moveEntitiesToDB`;
+    log.trace(origin);
+    try {
+      return super.moveEntitiesToDB(callback);
+    } catch (err) {
+      log.error(`${origin}: ${err}`);
+      return callback(null, err);
+    }
+  }
+
   /**
    * @summary Determines if this adapter supports the specific entity
    *
@@ -528,6 +546,456 @@ class Zscaler extends AdapterBaseCl {
     }
   }
 
+  /* BROKER CALLS */
+  /**
+   * @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);
+
+    if (this.suspended && this.suspendMode === 'error') {
+      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], 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
+        const uriPath = `/call/toget/device/${uuid}`;
+        return this.genericAdapterRequest(uriPath, 'GET', {}, {}, {}, (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 || !result.response.applianceMo) {
+            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;
+          thisDevice.name = thisDevice.systemName;
+          thisDevice.ostype = `System-${thisDevice.systemType}`;
+          thisDevice.port = thisDevice.systemPort;
+          thisDevice.ipaddress = thisDevice.systemIP;
+          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);
+
+    // 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
+      const uriPath = '/call/toget/devices';
+      return this.genericAdapterRequest(uriPath, 'GET', {}, {}, {}, (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;
+            thisDevice.name = thisDevice.systemName;
+            thisDevice.ostype = `System-${thisDevice.systemType}`;
+            thisDevice.port = thisDevice.systemPort;
+            thisDevice.ipaddress = thisDevice.systemIP;
+
+            // 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;
+        thisDevice.name = thisDevice.systemName;
+        thisDevice.ostype = `System-${thisDevice.systemType}`;
+        thisDevice.port = thisDevice.systemPort;
+        thisDevice.ipaddress = thisDevice.systemIP;
+
+        // 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);
+
+    // 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
+        const uriPath = `/call/toget/status/${uuid}`;
+        return this.genericAdapterRequest(uriPath, 'GET', {}, {}, {}, (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 || !Object.hasOwnProperty.call(result.response.returnObj, 'statusField')) {
+            const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['isAlive'], null, null, null);
+            log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+            return callback(null, errorObj);
+          }
+
+          // !! return the response - Update to the appropriate object/field
+          return callback(!result.response.returnObj.statusField);
+        });
+      });
+    } 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);
+
+    // 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
+        const uriPath = `/call/toget/config/${uuid}`;
+        return this.genericAdapterRequest(uriPath, 'GET', {}, {}, {}, (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 getCount
+   *
+   * @param {getCallback} callback - callback function to return the result
+   *                                    (count) or the error
+   */
+  getCount(callback) {
+    const meth = 'adapter-getCount';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // verify the required fields have been provided
+
+    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
+      const uriPath = '/call/toget/count';
+      return this.genericAdapterRequest(uriPath, 'GET', {}, {}, {}, (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);
+    }
+  }
+
   /**
    * @callback healthCallback
    * @param {Object} result - the result of the get request (contains an id and a status)

package/adapterBase.js

@@ -822,7 +822,7 @@ class AdapterBase extends EventEmitterCl {
    */
   async runConnectivity(callback) {
     try {
-      const { serviceItem } = await troubleshootingAdapter.getAdapterConfig();
+      const { serviceItem } = await tbUtils.getAdapterConfig();
       const { host } = serviceItem.properties.properties;
       const result = tbUtils.runConnectivity(host, false);
       if (result.failCount > 0) {

package/entities/.system/action.json

@@ -30,7 +30,7 @@
       "name": "healthcheck",
       "protocol": "REST",
       "method": "GET",
-      "entitypath": "{base_path}/{version}/healthcheck?{query}",
+      "entitypath": "{base_path}/{version}/authenticatedSession",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -48,4 +48,4 @@
       ]
     }
   ]
-}
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@itentialopensource/adapter-zscaler",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "description": "This adapter integrates with system Zscaler",
   "main": "adapter.js",
   "wizardVersion": "2.44.7",
-  "engineVersion": "1.59.46",
+  "engineVersion": "1.59.55",
   "adapterType": "http",
   "scripts": {
     "artifactize": "npm i && node utils/packModificationScript.js",

package/pronghorn.json

@@ -386,6 +386,198 @@
       },
       "task": true
     },
+    {
+      "name": "moveEntitiesToDB",
+      "summary": "Moves entities from an adapter into the IAP database",
+      "description": "Moves entities from an adapter into the IAP database",
+      "input": [],
+      "output": {
+        "name": "res",
+        "type": "object",
+        "description": "A JSON Object containing status, code and the response from the mongo transaction",
+        "schema": {
+          "title": "res",
+          "type": "object"
+        }
+      },
+      "roles": [
+        "admin"
+      ],
+      "route": {
+        "verb": "POST",
+        "path": "/moveEntitiesToDB"
+      },
+      "task": true
+    },
+    {
+      "name": "getDevice",
+      "summary": "Get the Appliance",
+      "description": "Get the Appliance",
+      "input": [
+        {
+          "name": "deviceName",
+          "type": "string",
+          "info": "An Appliance Device Name",
+          "required": true,
+          "schema": {
+            "title": "deviceName",
+            "type": "string"
+          }
+        }
+      ],
+      "output": {
+        "name": "result",
+        "type": "object",
+        "description": "A JSON Object containing status, code and the result",
+        "schema": {
+          "title": "result",
+          "type": "object"
+        }
+      },
+      "roles": [
+        "admin"
+      ],
+      "route": {
+        "verb": "POST",
+        "path": "/getDevice"
+      },
+      "task": false
+    },
+    {
+      "name": "getDevicesFiltered",
+      "summary": "Get Appliances that match the filter",
+      "description": "Get Appliances that match the filter",
+      "input": [
+        {
+          "name": "options",
+          "type": "object",
+          "info": "options - e.g. { 'start': 1, 'limit': 20, 'filter': { 'name': 'abc123' } }",
+          "required": true,
+          "schema": {
+            "title": "options",
+            "type": "object"
+          }
+        }
+      ],
+      "output": {
+        "name": "result",
+        "type": "array",
+        "description": "A JSON Object containing status, code and the result",
+        "schema": {
+          "title": "result",
+          "type": "array"
+        }
+      },
+      "roles": [
+        "admin"
+      ],
+      "route": {
+        "verb": "POST",
+        "path": "/getDevicesFiltered"
+      },
+      "task": false
+    },
+    {
+      "name": "isAlive",
+      "summary": "Checks the status for the provided Appliance",
+      "description": "Checks the status for the provided Appliance",
+      "input": [
+        {
+          "name": "deviceName",
+          "type": "string",
+          "info": "An Appliance Device Name",
+          "required": true,
+          "schema": {
+            "title": "deviceName",
+            "type": "string"
+          }
+        }
+      ],
+      "output": {
+        "name": "result",
+        "type": "boolean",
+        "description": "A JSON Object containing status, code and the result",
+        "schema": {
+          "title": "result",
+          "type": "boolean"
+        }
+      },
+      "roles": [
+        "admin"
+      ],
+      "route": {
+        "verb": "POST",
+        "path": "/isAlive"
+      },
+      "task": false
+    },
+    {
+      "name": "getConfig",
+      "summary": "Gets a config for the provided Appliance",
+      "description": "Gets a config for the provided Appliance",
+      "input": [
+        {
+          "name": "deviceName",
+          "type": "string",
+          "info": "An Appliance Device Name",
+          "required": true,
+          "schema": {
+            "title": "deviceName",
+            "type": "string"
+          }
+        },
+        {
+          "name": "format",
+          "type": "string",
+          "info": "The format to be returned - this is ignored as we always return json",
+          "required": false,
+          "schema": {
+            "title": "format",
+            "type": "string"
+          }
+        }
+      ],
+      "output": {
+        "name": "result",
+        "type": "object",
+        "description": "A JSON Object containing status, code and the result",
+        "schema": {
+          "title": "result",
+          "type": "object"
+        }
+      },
+      "roles": [
+        "admin"
+      ],
+      "route": {
+        "verb": "POST",
+        "path": "/getConfig"
+      },
+      "task": false
+    },
+    {
+      "name": "getCount",
+      "summary": "Gets a device count from the system",
+      "description": "Gets a device count from the system",
+      "input": [],
+      "output": {
+        "name": "result",
+        "type": "object",
+        "description": "A JSON Object containing status, code and the result",
+        "schema": {
+          "title": "result",
+          "type": "object"
+        }
+      },
+      "roles": [
+        "admin"
+      ],
+      "route": {
+        "verb": "POST",
+        "path": "/getCount"
+      },
+      "task": false
+    },
     {
       "name": "getAuthenticatedSession",
       "summary": "Checks if there is an authenticated session",

package/report/updateReport1642619799800.json

@@ -0,0 +1,95 @@
+{
+  "errors": [],
+  "statistics": [
+    {
+      "owner": "errorJson",
+      "description": "New adapter errors available for use",
+      "value": 0
+    },
+    {
+      "owner": "errorJson",
+      "description": "Adapter errors no longer available for use",
+      "value": 0
+    },
+    {
+      "owner": "errorJson",
+      "description": "Adapter errors that have been updated (e.g. recommendation changes)",
+      "value": 30
+    },
+    {
+      "owner": "packageJson",
+      "description": "Number of production dependencies",
+      "value": 13
+    },
+    {
+      "owner": "packageJson",
+      "description": "Number of development dependencies",
+      "value": 7
+    },
+    {
+      "owner": "packageJson",
+      "description": "Number of npm scripts",
+      "value": 23
+    },
+    {
+      "owner": "packageJson",
+      "description": "Runtime Library dependency",
+      "value": "^4.44.11"
+    },
+    {
+      "owner": "propertiesSchemaJson",
+      "description": "Adapter properties defined in the propertiesSchema file",
+      "value": 65
+    },
+    {
+      "owner": "readmeMd",
+      "description": "Number of lines in the README.md",
+      "value": 688
+    },
+    {
+      "owner": "unitTestJS",
+      "description": "Number of lines of code in unit tests",
+      "value": 2357
+    },
+    {
+      "owner": "unitTestJS",
+      "description": "Number of unit tests",
+      "value": 130
+    },
+    {
+      "owner": "integrationTestJS",
+      "description": "Number of lines of code in integration tests",
+      "value": 2130
+    },
+    {
+      "owner": "integrationTestJS",
+      "description": "Number of integration tests",
+      "value": 62
+    },
+    {
+      "owner": "staticFile",
+      "description": "Number of lines of code in adapterBase.js",
+      "value": 1029
+    },
+    {
+      "owner": "staticFile",
+      "description": "Number of static files added",
+      "value": 34
+    },
+    {
+      "owner": "Overall",
+      "description": "Total lines of Code",
+      "value": 5516
+    },
+    {
+      "owner": "Overall",
+      "description": "Total Tests",
+      "value": 192
+    },
+    {
+      "owner": "Overall",
+      "description": "Total Files",
+      "value": 6
+    }
+  ]
+}

package/test/integration/adapterTestIntegration.js

@@ -13,7 +13,10 @@ const winston = require('winston');
 const { expect } = require('chai');
 const { use } = require('chai');
 const td = require('testdouble');
+const util = require('util');
+const pronghorn = require('../../pronghorn.json');
 
+pronghorn.methodsByName = pronghorn.methods.reduce((result, meth) => ({ ...result, [meth.name]: meth }), {});
 const anything = td.matchers.anything();
 
 // stub and attemptTimeout are used throughout the code so set them here
@@ -63,7 +66,10 @@ global.pronghornProps = {
           invalid_token_error: 401,
           auth_field: 'header.headers.Authorization',
           auth_field_format: 'Basic {b64}{username}:{password}{/b64}',
-          auth_logging: false
+          auth_logging: false,
+          client_id: '',
+          client_secret: '',
+          grant_type: ''
         },
         healthcheck: {
           type: 'startup',

package/test/unit/adapterTestUnit.js

@@ -65,7 +65,10 @@ global.pronghornProps = {
           invalid_token_error: 401,
           auth_field: 'header.headers.Authorization',
           auth_field_format: 'Basic {b64}{username}:{password}{/b64}',
-          auth_logging: false
+          auth_logging: false,
+          client_id: '',
+          client_secret: '',
+          grant_type: ''
         },
         healthcheck: {
           type: 'startup',
@@ -1129,6 +1132,18 @@ describe('[unit] Zscaler Adapter Test', () => {
       });
     });
 
+    describe('#moveEntitiesToDB', () => {
+      it('should have a moveEntitiesToDB function', (done) => {
+        try {
+          assert.equal(true, typeof a.moveEntitiesToDB === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
     describe('#checkActionFiles', () => {
       it('should have a checkActionFiles function', (done) => {
         try {
@@ -1258,6 +1273,90 @@ describe('[unit] Zscaler Adapter Test', () => {
     //   }).timeout(attemptTimeout);
     // });
 
+    describe('#hasEntities', () => {
+      it('should have a hasEntities function', (done) => {
+        try {
+          assert.equal(true, typeof a.hasEntities === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#hasDevices', () => {
+      it('should have a hasDevices function', (done) => {
+        try {
+          assert.equal(true, typeof a.hasDevices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getDevice', () => {
+      it('should have a getDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getDevicesFiltered', () => {
+      it('should have a getDevicesFiltered function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDevicesFiltered === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#isAlive', () => {
+      it('should have a isAlive function', (done) => {
+        try {
+          assert.equal(true, typeof a.isAlive === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getConfig', () => {
+      it('should have a getConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.getConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getCount', () => {
+      it('should have a getCount function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCount === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
     /*
     -----------------------------------------------------------------------
     -----------------------------------------------------------------------

package/utils/basicGet.js

@@ -6,11 +6,8 @@
 /* eslint import/no-unresolved: warn */
 /* eslint import/no-dynamic-require: warn */
 
-const path = require('path');
 const winston = require('winston');
 
-const utils = require(path.join(__dirname, 'tbUtils'));
-
 const logLevel = 'none';
 const myCustomLevels = {
   levels: {
@@ -47,20 +44,6 @@ const basicGet = {
       adapter.id,
       adapterProps
     );
-  },
-
-  /**
-   * @summary connect to mongodb
-   *
-   * @function connect
-   * @param {Object} properties - pronghornProps
-   */
-  connect: async function connect(properties) {
-    // Connect to Mongo
-    const { MongoDBConnection } = require(path.join(utils.getDirname(), '../../../', '@itential/database'));
-    const connection = new MongoDBConnection(properties.mongoProps);
-    const database = await connection.connect(true);
-    return database;
   }
 };
 

package/utils/modify.js

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

package/utils/patches2bundledDeps.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const semverSatisfies = require('semver/functions/satisfies');
+const packageJson = require('../package.json');
+
+try {
+  // pattern supplied by semver.org via https://regex101.com/r/vkijKf/1/ but removed gm from end to only match a single semver
+  // const semverPat = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+  // pattern supplied by semver.org via https://regex101.com/r/Ly7O1x/3/ with following changes
+  // removed P's from before capturing group names and
+  // removed  gm from end to only match a single semver
+  // const semverPat = /^(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+  const patches = (fs.existsSync('./patches')) ? fs.readdirSync('./patches', { withFileTypes: true }) : [];
+  if (!patches.length) {
+    console.error('\nno patches - nothing to do\n');
+    process.exitCode = 1;
+  }
+
+  const dependencies = packageJson.dependencies || {};
+  if (!Object.keys(dependencies).length) {
+    console.error('\nno dependencies - nothing to do\n');
+    process.exitCode = 1;
+  }
+
+  let changed = false;
+  console.error('\nprocessing patches');
+  const bundledDependencies = packageJson.bundledDependencies || packageJson.bundleDependencies || [];
+
+  patches.forEach((patch) => {
+    if (!patch.isFile()) {
+      console.error(`${patch.name} skipped, is not a regular file`);
+      return;
+    }
+    if (!patch.name.endsWith('.patch')) {
+      console.error(`${patch.name} skipped, does not end with .patch`);
+      return;
+    }
+    const splits = patch.name.slice(0, -6).split('+');
+    if (splits.length > 4) {
+      console.error(`${patch.name} skipped, does not follow the naming convention (cannot use '+' other than to separate scope/package/semver and at most once within semver)`);
+      return;
+    }
+    const scope = splits[0][0] === '@' ? splits.shift() : null;
+    const packageName = splits.shift();
+    const semver = splits.join('+');
+    // const { groups } = semver.match(semverPat);
+    const file = scope ? `${scope}/${packageName}` : packageName;
+    if (dependencies[file] && semverSatisfies(semver, dependencies[file])) {
+      if (!bundledDependencies.includes(file)) {
+        bundledDependencies.push(file);
+        console.error(`added ${file} to bundledDependencies`);
+        changed = true;
+      } else {
+        console.error(`bundledDependencies already has ${file}`);
+      }
+    } else {
+      const depmsg = dependencies[file] ? `version mismatch (${dependencies[file]}) in dependencies` : 'not found in dependencies';
+      console.error(`patch ${patch.name} ${depmsg}`);
+    }
+  });
+
+  if (!packageJson.bundledDependencies && bundledDependencies.length) {
+    delete packageJson.bundleDependencies;
+    packageJson.bundledDependencies = bundledDependencies;
+    console.error('renaming bundleDependencies to bundledDependencies');
+    changed = true;
+  }
+  if (changed) {
+    fs.writeFileSync('./package.json.new', JSON.stringify(packageJson, null, 2));
+    console.error('wrote package.json.new');
+    fs.renameSync('./package.json', './package.json.old');
+    console.error('moved package.json to package.json.old');
+    fs.renameSync('./package.json.new', './package.json');
+    console.error('moved package.json.new to package.json');
+  } else {
+    console.error('no changes\n');
+    process.exitCode = 1;
+  }
+} catch (e) {
+  if (e) {
+    // caught error, exit with status 2 to signify abject failure
+    console.error(`\ncaught exception - ${e}\n`);
+    process.exitCode = 2;
+  } else {
+    // caught false, exit with status 1 to signify nothing done
+    process.exitCode = 1;
+  }
+} finally {
+  console.error('done\n');
+}

package/utils/tbScript.js

@@ -17,11 +17,11 @@ const sampleProperties = require('../sampleProperties.json');
 const adapterPronghorn = require('../pronghorn.json');
 const { addAuthInfo } = require('./addAuth');
 
-const { troubleshoot, getAdapterConfig, offline } = require('./troubleshootingAdapter');
+const { troubleshoot, offline } = require('./troubleshootingAdapter');
 
 const main = async (command) => {
   const dirname = utils.getDirname();
-  const iapDir = path.join(dirname, '../../../../');
+  const iapDir = path.join(dirname, '../../../');
   if (!utils.withinIAP(iapDir)) {
     if (command === 'install') {
       console.log('Not currently in IAP directory - installation not possible');
@@ -48,7 +48,7 @@ const main = async (command) => {
   if (command === undefined) {
     await troubleshoot({}, true, true);
   } else if (command === 'install') {
-    const { database, serviceItem, pronghornProps } = await getAdapterConfig();
+    const { database, serviceItem, pronghornProps } = await utils.getAdapterConfig();
     const filter = { id: pronghornProps.id };
     const profileItem = await database.collection(utils.IAP_PROFILES_COLLECTION).findOne(filter);
     if (!profileItem) {
@@ -101,7 +101,7 @@ const main = async (command) => {
       process.exit(0);
     }
   } else if (['healthcheck', 'basicget', 'connectivity'].includes(command)) {
-    const { serviceItem } = await getAdapterConfig();
+    const { serviceItem } = await utils.getAdapterConfig();
     if (serviceItem) {
       const adapter = serviceItem;
       const a = basicGet.getAdapterInstance(adapter);

package/utils/tbUtils.js

@@ -100,8 +100,8 @@ module.exports = {
    *
    * @function decryptProperties
    */
-  decryptProperties: (props, dirname, discovery) => {
-    const propertyEncryptionClassPath = path.join(dirname, '../../../@itential/pronghorn-core/core/PropertyEncryption.js');
+  decryptProperties: (props, iapDir, discovery) => {
+    const propertyEncryptionClassPath = path.join(iapDir, 'node_modules/@itential/pronghorn-core/core/PropertyEncryption.js');
     const isEncrypted = props.pathProps.encrypted;
     const PropertyEncryption = discovery.require(propertyEncryptionClassPath, isEncrypted);
     const propertyEncryption = new PropertyEncryption({
@@ -177,12 +177,12 @@ module.exports = {
   verifyInstallationDir: (dirname, name) => {
     const pathArray = dirname.split(path.sep);
     const expectedPath = `node_modules/${name}`;
-    const currentPath = pathArray.slice(pathArray.length - 4, pathArray.length - 1).join('/');
+    const currentPath = pathArray.slice(pathArray.length - 3, pathArray.length).join('/');
     if (currentPath.trim() !== expectedPath.trim()) {
-      throw new Error(`adapter should be installed under ${expectedPath}`);
+      throw new Error(`adapter should be installed under ${expectedPath} but is installed under ${currentPath}`);
     }
 
-    const serverFile = path.join(dirname, '../../../..', 'server.js');
+    const serverFile = path.join(dirname, '../../../', 'server.js');
     if (!fs.existsSync(serverFile)) {
       throw new Error(`adapter should be installed under IAP/${expectedPath}`);
     }
@@ -339,6 +339,37 @@ module.exports = {
     return adapter;
   },
 
+  getPronghornProps: function getPronghornProps(iapDir) {
+    console.log('Retrieving properties.json file...');
+    const rawProps = require(path.join(iapDir, 'properties.json'));
+    console.log('Decrypting properties...');
+    const { Discovery } = require(path.join(iapDir, 'node_modules/@itential/itential-utils'));
+    const discovery = new Discovery();
+    const pronghornProps = this.decryptProperties(rawProps, iapDir, discovery);
+    console.log('Found properties.\n');
+    return pronghornProps;
+  },
+
+  // get database connection and existing adapter config
+  getAdapterConfig: async function getAdapterConfig() {
+    const newDirname = this.getDirname();
+    let iapDir;
+    if (this.withinIAP(newDirname)) { // when this script is called from IAP
+      iapDir = newDirname;
+    } else {
+      iapDir = path.join(this.getDirname(), 'utils', '../../../../');
+    }
+    const pronghornProps = this.getPronghornProps(iapDir);
+    console.log('Connecting to Database...');
+    const database = await this.connect(iapDir, pronghornProps);
+    console.log('Connection established.');
+    const { name } = require(path.join(__dirname, '..', 'package.json'));
+    const serviceItem = await database.collection(this.SERVICE_CONFIGS_COLLECTION).findOne(
+      { model: name }
+    );
+    return { database, serviceItem, pronghornProps };
+  },
+
   /**
    * @summary return async healthcheck result as a Promise
    *
@@ -400,7 +431,21 @@ module.exports = {
       return __dirname;
     }
     const { stdout } = this.systemSync('pwd', true);
-    return path.join(stdout, 'utils');
+    return stdout.trim();
+  },
+
+  /**
+   * @summary connect to mongodb
+   *
+   * @function connect
+   * @param {Object} properties - pronghornProps
+   */
+  connect: async function connect(iapDir, properties) {
+    // Connect to Mongo
+    const { MongoDBConnection } = require(path.join(iapDir, 'node_modules/@itential/database'));
+    const connection = new MongoDBConnection(properties.mongoProps);
+    const database = await connection.connect(true);
+    return database;
   }
 
 };

package/utils/troubleshootingAdapter.js

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