@itentialopensource/adapter-nokia_altiplano 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,4 +1,20 @@
 
+## 0.1.3 [10-24-2021]
+
+* Fix the registry url
+
+See merge request itentialopensource/adapters/controller-orchestrator/adapter-nokia_altiplano!2
+
+---
+
+## 0.1.2 [10-24-2021]
+
+* change paths and add headers
+
+See merge request itentialopensource/adapters/controller-orchestrator/adapter-nokia_altiplano!1
+
+---
+
 ## 0.1.1 [07-29-2021]
 
 * Bug fixes and performance improvements
@@ -6,4 +22,3 @@
 See commit bff31d3
 
 ---
-

package/adapterBase.js

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

package/entities/.generic/action.json

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

package/entities/.system/action.json

@@ -9,9 +9,13 @@
       "responseSchema": "schemaTokenResp.json",
       "timeout": 0,
       "sendEmpty": false,
-      "requestDatatype": "",
-      "responseDatatype": "",
-      "headers": {},
+      "requestDatatype": "JSON",
+      "responseDatatype": "JSON",
+      "headers": {
+        "Authorization": "Basic {b64}{username}:{password}{/b64}",
+        "Content-Type": "",
+        "Accept": "*/*"
+      },
       "sso": {
         "protocol": "",
         "host": "",

package/entities/.system/schemaTokenResp.json

@@ -46,7 +46,7 @@
         "type": "AES",
         "key": ""
       },
-      "external_name": "token"
+      "external_name": "accessToken"
     }
   },
   "definitions": {}

package/entities/Intent/action.json

@@ -11,7 +11,10 @@
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -24,14 +27,17 @@
       "name": "dependentsSummaryForDevice",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1}/dependents-summary?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1}/dependents-summary?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -44,14 +50,17 @@
       "name": "getuplinkConnectionConfiguration",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/conf/operations/ibn:search-intents?{query}",
+      "entitypath": "{base_path}/{version}/restconf/operations/ibn:search-intents?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -64,14 +73,17 @@
       "name": "dependentsSummaryFiber",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},fiber/dependents-summary?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},fiber/dependents-summary?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -84,14 +96,17 @@
       "name": "createOnt",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -104,7 +119,7 @@
       "name": "getOnt",
       "protocol": "REST",
       "method": "GET",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},ont?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},ont?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -112,7 +127,10 @@
       "sendGetBody": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -125,14 +143,17 @@
       "name": "lockOnt",
       "protocol": "REST",
       "method": "PATCH",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},ont?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},ont?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -145,14 +166,17 @@
       "name": "deleteOnt",
       "protocol": "REST",
       "method": "DELETE",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},ont?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},ont?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -165,14 +189,17 @@
       "name": "synchronizeOnt",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},ont/synchronize?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},ont/synchronize?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -185,14 +212,17 @@
       "name": "auditOnt",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},ont/audit?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},ont/audit?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -205,14 +235,17 @@
       "name": "synchronizel2User",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},l2-user/synchronize?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},l2-user/synchronize?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -225,7 +258,7 @@
       "name": "getl2User",
       "protocol": "REST",
       "method": "GET",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},l2-user?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},l2-user?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
@@ -233,7 +266,10 @@
       "sendGetBody": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -246,14 +282,17 @@
       "name": "modifyl2User",
       "protocol": "REST",
       "method": "PATCH",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},l2-user?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},l2-user?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -266,14 +305,17 @@
       "name": "deletel2User",
       "protocol": "REST",
       "method": "DELETE",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},l2-user?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},l2-user?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",
@@ -286,14 +328,17 @@
       "name": "auditl2User",
       "protocol": "REST",
       "method": "POST",
-      "entitypath": "{base_path}/{version}/conf/data/ibn:ibn/{pathv1},l2-user/audit?{query}",
+      "entitypath": "{base_path}/{version}/restconf/data/ibn:ibn/{pathv1},l2-user/audit?{query}",
       "requestSchema": "schema.json",
       "responseSchema": "schema.json",
       "timeout": 0,
       "sendEmpty": false,
       "requestDatatype": "JSON",
       "responseDatatype": "JSON",
-      "headers": {},
+      "headers": {
+        "Content-Type": "application/yang-data+json",
+        "Accept": "application/yang-data+json"
+      },
       "responseObjects": [
         {
           "type": "default",

package/package.json

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

package/propertiesSchema.json

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

package/test/unit/adapterBaseTestUnit.js

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

package/test/unit/adapterTestUnit.js

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

package/utils/addAuth.js

@@ -0,0 +1,94 @@
+/* eslint-disable no-plusplus */
+/* eslint global-require: warn */
+/* eslint import/no-dynamic-require: warn */
+
+const rls = require('readline-sync');
+const path = require('path');
+const fs = require('fs');
+
+function getQuestions(props, obj) {
+  const questions = props.map((p) => `${p}: ${(obj[p] !== undefined) ? `(${obj[p]})` : ''} `);
+  return questions;
+}
+
+// function outputs each property for user to edit/confirm
+// props are the fields that need to be changed depending on what the user selects
+// obj is the JSON object that's being updated
+function confirm(props, obj) {
+  // create array of questions
+  const updatedObj = obj;
+  getQuestions(props, obj).forEach((q) => {
+    const answer = rls.question(q);
+    // only update the field if the answer is NOT and empty string
+    if (answer) {
+      updatedObj[q.split(':')[0].trim()] = answer;
+    }
+  });
+  return updatedObj;
+}
+
+const updateBasicAuth = (auth) => {
+  const propsToUpdate = ['username', 'password', 'auth_field', 'auth_field_format'];
+  return confirm(propsToUpdate, auth);
+};
+
+const updateStaticTokenAuth = (auth) => {
+  const propsToUpdate = ['token', 'auth_field', 'auth_field_format'];
+  return confirm(propsToUpdate, auth);
+};
+
+function updateTokenSchemas(user, pw, token) {
+  let schemaPath = path.join(__dirname, '..', 'entities/.system/schemaTokenReq.json');
+  const reqSchema = require(schemaPath);
+  reqSchema.properties.username.external_name = user;
+  reqSchema.properties.password.external_name = pw;
+  fs.writeFileSync(schemaPath, JSON.stringify(reqSchema, null, 2));
+  schemaPath = path.join(__dirname, '..', 'entities/.system/schemaTokenResp.json');
+  const respSchema = require(schemaPath);
+  respSchema.properties.token.external_name = token;
+  fs.writeFileSync(schemaPath, JSON.stringify(respSchema, null, 2));
+}
+
+function updateRequestToken(auth) {
+  const propsToUpdate = [
+    'username',
+    'password',
+    'auth_field',
+    'auth_field_format',
+    'token_user_field',
+    'token_password_field',
+    'token_result_field',
+    'token_URI_path'
+  ];
+  const newAuth = confirm(propsToUpdate, auth);
+  updateTokenSchemas(newAuth.token_user_field, newAuth.token_password_field, newAuth.token_result_field);
+
+  return newAuth;
+}
+
+// prompt users to pick an auth method from the list above
+const addAuthInfo = (props) => {
+  const authOptions = [
+    'basic user_password',
+    'static_token',
+    'request_token',
+    'no_authentication'
+  ];
+  const newProps = confirm(['host', 'port', 'base_path'], props);
+
+  const newAuthMethod = authOptions[rls.keyInSelect(authOptions, 'Which authentication method?')];
+  newProps.authentication.auth_method = newAuthMethod;
+
+  if (newAuthMethod === 'basic user_password') {
+    newProps.authentication = updateBasicAuth(newProps.authentication);
+  } else if (newAuthMethod === 'static_token') {
+    newProps.authentication = updateStaticTokenAuth(newProps.authentication);
+  } else if (newAuthMethod === 'request_token') {
+    newProps.authentication = updateRequestToken(newProps.authentication);
+  }
+  console.log('Connectivity and authentication properties have been configured');
+  console.log('If you want to make changes, rerun this script to reinstall the adapter');
+  return newProps;
+};
+
+module.exports = { addAuthInfo };

package/utils/basicGet.js

@@ -4,9 +4,13 @@
 /* eslint import/no-extraneous-dependencies: warn */
 /* eslint global-require: warn */
 /* 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: {
@@ -53,7 +57,7 @@ const basicGet = {
    */
   connect: async function connect(properties) {
     // Connect to Mongo
-    const { MongoDBConnection } = require('@itential/database');
+    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/entitiesToDB.js

@@ -0,0 +1,224 @@
+/* @copyright Itential, LLC 2021 */
+
+// Set globals
+/* global log */
+
+/* eslint import/no-dynamic-require: warn */
+/* eslint global-require: warn */
+/* eslint no-unused-vars: warn */
+/* eslint import/no-unresolved: warn */
+
+/**
+ *  This script is used to read through an adapter's entities files
+ *  and then creates documents and enters them into the IAP mongodb
+ */
+
+const fs = require('fs');
+const { MongoClient } = require('mongodb');
+const path = require('path');
+// const { argv } = require('process');
+// const { string } = require('yargs');
+
+// get the pronghorn database information
+const getPronghornProps = async (iapDir) => {
+  log.trace('Retrieving properties.json file...');
+  const rawProps = require(path.join(iapDir, 'properties.json'));
+  log.trace('Decrypting properties...');
+  const { PropertyEncryption } = require('@itential/itential-utils');
+  const propertyEncryption = new PropertyEncryption();
+  const pronghornProps = await propertyEncryption.decryptProps(rawProps);
+  log.trace('Found properties.\n');
+  return pronghornProps;
+};
+
+/**
+ *  Function used to take a file path to a entity directory and build
+ *  a document that corresponds to the entity files.
+ */
+const buildDoc = (pathstring) => {
+  let files = fs.readdirSync(pathstring);
+
+  // load the mockdatafiles
+  const mockdatafiles = {};
+  if (files.includes('mockdatafiles') && fs.lstatSync(`${pathstring}/mockdatafiles`).isDirectory()) {
+    fs.readdirSync(`${pathstring}/mockdatafiles`).forEach((file) => {
+      if (file.split('.').pop() === 'json') {
+        const mockpath = `${pathstring}/mockdatafiles/${file}`;
+        const data = JSON.parse(fs.readFileSync(mockpath));
+        mockdatafiles[mockpath.split('/').pop()] = data;
+      }
+    });
+  }
+
+  // load the action data
+  let actions;
+  if (files.includes('action.json')) {
+    actions = JSON.parse(fs.readFileSync(`${pathstring}/action.json`));
+  }
+
+  // Load schema.json and other schemas in remaining json files
+  files = files.filter((f) => (f !== 'action.json') && f.endsWith('.json'));
+  const schema = [];
+  files.forEach((file) => {
+    const data = JSON.parse(fs.readFileSync(`${pathstring}/${file}`));
+    schema.push({
+      name: file,
+      schema: data
+    });
+  });
+
+  // return the data
+  return {
+    actions: actions.actions,
+    schema,
+    mockdatafiles
+  };
+};
+
+/**
+ *  Function used to get the database from the options or a provided directory
+ */
+const optionsHandler = (options) => {
+  // if the database properties were provided in the options - return them
+  if (options.pronghornProps) {
+    if (typeof options.pronghornProps === 'string') {
+      return JSON.parse(options.pronghornProps);
+    }
+    return new Promise((resolve, reject) => resolve(options.pronghornProps));
+  }
+
+  // if the directory was provided, get the pronghorn props from the directory
+  if (options.iapDir) {
+    return getPronghornProps(options.iapDir);
+  }
+
+  // if nothing was provided, error
+  return new Promise((resolve, reject) => reject(new Error('Neither pronghornProps nor iapDir defined in options!')));
+};
+
+/**
+ *  Function used to put the adapter configuration into the provided database
+ */
+const moveEntitiesToDB = (targetPath, options) => {
+  // set local variables
+  let myOpts = options;
+  let myPath = targetPath;
+
+  // if we got a string parse into a JSON object
+  if (typeof myOpts === 'string') {
+    myOpts = JSON.parse(myOpts);
+  }
+
+  // if there is no target collection - set the collection to the default
+  if (!myOpts.targetCollection) {
+    myOpts.targetCollection = 'adapter_configs';
+  }
+
+  // if there is no id error since we need an id for the entities
+  if (!myOpts.id) {
+    throw new Error('Adapter ID required!');
+  }
+
+  // get the pronghorn database properties
+  optionsHandler(options).then((currentProps) => {
+    let mongoUrl;
+    let dbName;
+
+    // find the mongo properties so we can connect
+    if (currentProps.mongoProps) {
+      mongoUrl = currentProps.mongoProps.url;
+      dbName = currentProps.mongoProps.db;
+    } else if (currentProps.mongo) {
+      if (currentProps.mongo.url) {
+        mongoUrl = currentProps.mongo.url;
+      } else {
+        mongoUrl = `mongodb://${currentProps.mongo.host}:${currentProps.mongo.port}`;
+      }
+      dbName = currentProps.mongo.database;
+    } else {
+      throw new Error('Mongo properties are not specified in adapter preferences!');
+    }
+
+    // Check valid filepath provided
+    if (!myPath) {
+      // if no path use the current directory without the utils
+      myPath = path.join(__dirname, '../');
+    } else if (myPath.slice(-1) === '/') {
+      myPath = myPath.slice(0, -1);
+    }
+
+    // verify set the entity path
+    const entitiesPath = `${myPath}/entities`;
+    if (!fs.existsSync(entitiesPath)) {
+      throw new Error(`Entities path does not exist in filesystem: ${entitiesPath}`);
+    } else {
+      log.trace('Target found on filesystem');
+    }
+
+    // Get adapter details
+    if (!fs.existsSync(`${myPath}/pronghorn.json`)) {
+      throw new Error(`pronghorn.json does not exist in path: ${myPath}`);
+    } else {
+      log.trace('pronghorn.json found on filesystem');
+    }
+    const adapterData = JSON.parse(fs.readFileSync(`${myPath}/pronghorn.json`));
+
+    // Load files from the filesystem
+    const docs = [];
+    const entities = fs.readdirSync(entitiesPath);
+    entities.forEach((entity) => {
+      const entityPath = `${entitiesPath}/${entity}`;
+      const isDir = fs.lstatSync(entitiesPath).isDirectory();
+
+      // Build doc for entity
+      if (isDir) {
+        let doc = buildDoc(entityPath);
+        doc = {
+          id: myOpts.id,
+          type: adapterData.id,
+          entity,
+          ...doc
+        };
+        docs.push(doc);
+      }
+    });
+
+    // Upload documents to db collection
+    MongoClient.connect(mongoUrl, (err, db) => {
+      if (err) {
+        log.error(JSON.stringify(err));
+        throw err;
+      }
+
+      // get the proper collection
+      const collection = db.db(dbName).collection(myOpts.targetCollection);
+      // insert the documents into the collection
+      collection.insertMany(docs, { checkKeys: false }, (error, res) => {
+        if (error) {
+          log.error(JSON.stringify(error));
+          throw error;
+        }
+        // log the insertion, close the database and return
+        log.debug(`Inserted ${docs.length} documents to ${dbName}.${myOpts.targetCollection} with response ${JSON.stringify(res)}`);
+        db.close();
+        return res;
+      });
+    });
+  });
+};
+
+// const args = process.argv.slice(2);
+
+// throw new SyntaxError(args[0]);
+
+// if (args.length === 0) {
+//   console.error('ERROR: target path not specified!');
+// } else if (args[0] === 'help') {
+//   log.trace('node ./entitiesToDB <target path> <options object: {iapDir: string, pronghornProps: string, targetCollection: string}>');
+// } else if (args.length === 1) {
+//   console.error('ERROR: IAP directory not specified');
+// } else {
+//   moveEntitiesToDB(args[0], args[1]);
+// }
+
+module.exports = { moveEntitiesToDB };

package/utils/removeHooks.js

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

package/utils/tbScript.js

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

package/utils/tbUtils.js

@@ -178,7 +178,7 @@ module.exports = {
     const pathArray = dirname.split(path.sep);
     const expectedPath = `node_modules/${name}`;
     const currentPath = pathArray.slice(pathArray.length - 4, pathArray.length - 1).join('/');
-    if (expectedPath !== currentPath) {
+    if (currentPath.trim() !== expectedPath.trim()) {
       throw new Error(`adapter should be installed under ${expectedPath}`);
     }
 
@@ -304,8 +304,9 @@ module.exports = {
    * @param {Object} adapterPronghorn - ./pronghorn.json in adapter dir
    * @param {Object} sampleProperties - './sampleProperties.json' in adapter dir
    */
-  createAdapter: (pronghornProps, profileItem, sampleProperties, adapterPronghorn) => {
-    const packagePath = `${__dirname.split('node_modules')[0]}package.json`;
+  createAdapter: function createAdapter(pronghornProps, profileItem, sampleProperties, adapterPronghorn) {
+    const dirname = this.getDirname();
+    const packagePath = `${dirname.split('node_modules')[0]}package.json`;
     const info = JSON.parse(fs.readFileSync(packagePath));
     const version = parseInt(info.version.split('.')[0], 10);
 
@@ -385,5 +386,21 @@ module.exports = {
     } catch (error) {
       return false;
     }
+  },
+
+  /**
+   * @summary Used to determine the proper dirname to return in case adapter reference is
+   * symlinked withink IAP
+   * @returns the symlinked path (using pwd command) of the adapter in case properties.json
+   * is not found in the original path
+   * @function getDirname
+   */
+  getDirname: function getDirname() {
+    if (this.withinIAP(path.join(__dirname, '../../../../'))) {
+      return __dirname;
+    }
+    const { stdout } = this.systemSync('pwd', true);
+    return path.join(stdout, 'utils');
   }
+
 };

package/utils/troubleshootingAdapter.js

@@ -121,16 +121,16 @@ const getPronghornProps = (iapDir) => {
   console.log('Retrieving properties.json file...');
   const rawProps = require(path.join(iapDir, 'properties.json'));
   console.log('Decrypting properties...');
-  const { Discovery } = require('@itential/itential-utils');
+  const { Discovery } = require(path.join(iapDir, 'node_modules/@itential/itential-utils'));
   const discovery = new Discovery();
-  const pronghornProps = utils.decryptProperties(rawProps, __dirname, 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(__dirname, '../../../../');
+  const iapDir = path.join(utils.getDirname(), '../../../../');
   const pronghornProps = getPronghornProps(iapDir);
   console.log('Connecting to Database...');
   const database = await basicGet.connect(pronghornProps);