@getjones/test-infra 1.1.4 → 1.1.7

package/README.md

@@ -2,22 +2,22 @@
 
 ## Package Goal
 
-* Providing an easy and reusable interface for the backend system. Means, both by the OpenAPI, and the internal API.
+- Providing an easy and reusable interface for the backend system. Means, both by the OpenAPI, and the internal API.
 
 ## Interface
 
 ### init
 
-* require the package with settled up configuration json
+- require the package with settled up configuration json
 
 ```node
-const { internalAPI } = require('@getjones/test-infra')(conf);
+const { internalAPI } = require("@getjones/test-infra")(conf);
 ```
 
-* configuration example
+- configuration example
 
 ```node
-const dotenv = require('dotenv');
+const dotenv = require("dotenv");
 
 dotenv.config();
 
@@ -36,12 +36,12 @@ module.exports = {
 
 ### internalAPI
 
-* internalAPI contains the next services:
-    * auth
-    * accounts
-    * accountSettings
-    * projects
-    * projectSettings
+- internalAPI contains the next services:
+  - auth
+  - accounts
+  - accountSettings
+  - projects
+  - projectSettings
 
 ```node
 const { auth, accounts, accountSettings, projects } = internalAPI;
@@ -50,32 +50,28 @@ const { auth, accounts, accountSettings, projects } = internalAPI;
 ### auth
 
 ```node
-
 /**
  *
  * @param email (string)
  * @param password (string)
  * @return Auth cookie (string) with given email privileges.
  */
-const getAuthCookie = async (email, password) => {
-};
+const getAuthCookie = async (email, password) => {};
 
 /**
  *
  * Required Configuration: {
  * credentials.superUser,
- * credentials.superUserPassword 
+ * credentials.superUserPassword
  * }
  * @return ICS cookie (String)
  */
-const getIcsCookie = async () => {
-};
+const getIcsCookie = async () => {};
 ```
 
 ### accounts
 
 ```node
-
 /**
  *
  * Required Configuration: {
@@ -92,10 +88,13 @@ const getIcsCookie = async () => {
  * @return Account (object)
  */
 
-const createAccount = async (email, accountName, context,
+const createAccount = async (
+  email,
+  accountName,
+  context,
   password = credentials.strongPassword,
-  propertyType = PROPERTY_TYPE) => {
-};
+  propertyType = PROPERTY_TYPE
+) => {};
 
 /**
  *
@@ -103,8 +102,7 @@ const createAccount = async (email, accountName, context,
  * @param context (string): Should contains ICS cookie
  * @return Account (object)
  */
-const getAccount = async (accountName, context) => {
-};
+const getAccount = async (accountName, context) => {};
 
 /**
  *
@@ -114,8 +112,12 @@ const getAccount = async (accountName, context) => {
  * @param password (string)
  * @return Account (object)
  */
-const getOrCreateAccount = async (email, accountName, context, password = credentials.strongPassword) => {
-};
+const getOrCreateAccount = async (
+  email,
+  accountName,
+  context,
+  password = credentials.strongPassword
+) => {};
 
 /**
  *
@@ -123,8 +125,7 @@ const getOrCreateAccount = async (email, accountName, context, password = creden
  * @param context (string): Should contain ICS cookie
  * @return Account ID (String)
  */
-const getAccountId = async (accountName, context) => {
-};
+const getAccountId = async (accountName, context) => {};
 
 /**
  *
@@ -132,8 +133,7 @@ const getAccountId = async (accountName, context) => {
  * @param context (string): Should contains ICS cookie
  * @return Http Response
  */
-const deleteAccountByName = async (accountName, context) => {
-};
+const deleteAccountByName = async (accountName, context) => {};
 
 /**
  *
@@ -141,22 +141,19 @@ const deleteAccountByName = async (accountName, context) => {
  * @param context (string): Should contain ICS cookie
  * @return Http Response
  */
-const deleteAccountById = async (accountId, context) => {
-};
+const deleteAccountById = async (accountId, context) => {};
 ```
 
 ### accountSettings
 
 ```node
-
 /**
  *
  * @param accountId (string)
  * @param context (string): Should contain ICS cookie
  * @return Account Settings (object)
  */
-const getAccountSettings = async (accountId, context) => {
-};
+const getAccountSettings = async (accountId, context) => {};
 
 /**
  *
@@ -167,8 +164,12 @@ const getAccountSettings = async (accountId, context) => {
  * @param context (string): Should contain ICS cookie
  * @return Http Response
  */
-const updateAccountSettings = async (accountId, isMultiPropertyTenants, isHighPriority, context) => {
-};
+const updateAccountSettings = async (
+  accountId,
+  isMultiPropertyTenants,
+  isHighPriority,
+  context
+) => {};
 
 /**
  * Summary: Change account settings to default
@@ -180,15 +181,12 @@ const updateAccountSettings = async (accountId, isMultiPropertyTenants, isHighPr
  * @param context (string): Should Contain ICS cookie
  * @return Http Response
  */
-const restoreAccountSettings = async (accountId, context) => {
-};
-
+const restoreAccountSettings = async (accountId, context) => {};
 ```
 
 ### projects
 
 ```node
-
 /**
  *
  * @param accountName (string)
@@ -196,8 +194,7 @@ const restoreAccountSettings = async (accountId, context) => {
  * User's cookie that is related to this account or ICS cookie
  * @return List of projects ([objects])
  */
-const getProjectsByAccountName = async (accountName, context) => {
-};
+const getProjectsByAccountName = async (accountName, context) => {};
 
 /**
  *
@@ -206,8 +203,7 @@ const getProjectsByAccountName = async (accountName, context) => {
  * User's cookie that is related to this account or ICS cookie
  * @return List of projects ([objects])
  */
-const getProjectsByAccountId = async (accountId, context) => {
-};
+const getProjectsByAccountId = async (accountId, context) => {};
 
 /**
  *
@@ -217,8 +213,7 @@ const getProjectsByAccountId = async (accountId, context) => {
  * User's cookie that is related to this account or ICS cookie
  * @return List of projects ([objects])
  */
-const getProjectsByName = async (accountId, projectName, context) => {
-};
+const getProjectsByName = async (accountId, projectName, context) => {};
 
 /**
  * Summary: Delete project by given details
@@ -228,8 +223,7 @@ const getProjectsByName = async (accountId, projectName, context) => {
  * User's cookie that is related to this account or ICS cookie
  * @return List of projects ([objects])
  */
-const deleteProjectByName = async (accountId, projectName, context) => {
-};
+const deleteProjectByName = async (accountId, projectName, context) => {};
 
 /**
  *
@@ -242,40 +236,37 @@ const deleteProjectByName = async (accountId, projectName, context) => {
 
 // Example for project input (Not all of them are required):
 const createProjectInput = {
-  'projectName': project.name,
-  'userId': '',
-  'projectDescription': project.description,
-  'address': project.address,
-  'projectNumber': project.number,
-  'projectStartDate': project.startDate,
-  'projectEndDate': project.endDate,
-  'city': project.city,
-  'state': project.state,
-  'zipCode': project.zipCode,
-  'companyNameForProject': project.companyNameForProject,
-  'certificateHolder': '',
-  'additionalInsured': '',
-  'tenantSolutionEnabled': '',
-  'onboardingEnabled': '',
-  'automaticRenewalEnabled': ''
+  projectName: project.name,
+  userId: "",
+  regionOrDivision: project.description,
+  address: project.address,
+  projectNumber: project.number,
+  projectStartDate: project.startDate,
+  projectEndDate: project.endDate,
+  city: project.city,
+  state: project.state,
+  zipCode: project.zipCode,
+  companyNameForProject: project.companyNameForProject,
+  certificateHolder: "",
+  additionalInsured: "",
+  tenantSolutionEnabled: "",
+  onboardingEnabled: "",
+  automaticRenewalEnabled: "",
 };
 
-const createProject = async (project, accountName, context) => {
-};
+const createProject = async (project, accountName, context) => {};
 ```
 
 ### projectSettings
 
 ```node
-
 /**
  *
  * @param accountName (string)
  * @param context (string): Should contain cookie
  */
- 
-const getProjectsByAccountName = async (accountName, context) => {
-};
+
+const getProjectsByAccountName = async (accountName, context) => {};
 
 /**
  *
@@ -283,31 +274,25 @@ const getProjectsByAccountName = async (accountName, context) => {
  * @param context (string): Should contain cookie
  */
 
-const updateProjectSettingsByProjectId = async (settings, context) => {
-};
+const updateProjectSettingsByProjectId = async (settings, context) => {};
 
 // Example for settings input (Not all of them are required):
 const updateProjectSettingsInput = {
   autoGaps: {
     Guests: false,
     Tenants: false,
-    Vendors: false
-},
-    autoRenewels: false,
-  marketplace:  {
+    Vendors: false,
+  },
+  autoRenewels: false,
+  marketplace: {
     marketplaceEnabled: false,
     marketplacePreApproved: false,
-    marketplacePublicLink: false
-},
-    ocrEnabled: false,
-    onboardingPhase: false,
-    projectId: null,
-    qrEnabled: false,
-    tenantSolution: false
+    marketplacePublicLink: false,
+  },
+  ocrEnabled: false,
+  onboardingPhase: false,
+  projectId: null,
+  qrEnabled: false,
+  tenantSolution: false,
 };
-
 ```
-
-
-
-

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@getjones/test-infra",
-  "version": "1.1.4",
+  "version": "1.1.7",
   "description": "Providing internal and openapi interface",
   "main": "src/index.js",
   "scripts": {
-    "test": "mocha  \"./tests/**/*.test.js\" --slow 3000 --timeout 10000 --exit --inlineDiffs --bail"
+    "test": "mocha  \"./tests/**/*.test.js\" --slow 3000 --timeout 10000 --exit --inlineDiffs --bail",
+    "eslint-fix": "eslint \"./src/**/*.js\" --fix"
   },
   "author": "",
   "license": "ISC",

package/src/common/httpResponseStatusCodes.json

@@ -0,0 +1,12 @@
+{
+    "OK": 200,
+    "NO_CONTENT": 204,
+    "IM_USED": 226,
+    "BAD_REQUEST": 400,
+    "UNAUTHORIZED": 401,
+    "FORBIDDEN": 403,
+    "NOT_FOUND": 404,
+    "CONFLICT": 409,
+    "TOO_MANY_REQUESTS": 429,
+    "CLIENT_CLOSED_REQUEST": 499
+}

package/src/common/validations/errorValidation.js

@@ -0,0 +1,16 @@
+const responseStatusCodes = require('../httpResponseStatusCodes.json');
+
+const validateError = error=> {
+    if (!error.response || !isClientErrorCode(error.response.status)) {
+        throw error;
+    }
+};
+
+const isClientErrorCode = httpStatusCode =>{
+    const minClientErrorCode = responseStatusCodes.BAD_REQUEST;
+    const maxClientErrorCode = responseStatusCodes.CLIENT_CLOSED_REQUEST;
+
+    return httpStatusCode >= minClientErrorCode && httpStatusCode <= maxClientErrorCode;
+};
+
+module.exports = { validateError };

package/src/env.js

@@ -23,12 +23,12 @@ const requiredValidation = object => {
     const invalidKeys = [];
     Object.keys(object).forEach(key => {
         if (!object[key]) {
-            invalidKeys.push(key);
+            invalidKeys.push(` '${key}'`);
         }
     });
 
     if (invalidKeys.length > 0) {
-        throw `Missing required configuration on your environment variables. The missing env-vars are "${invalidKeys}".`;
+        throw Error(`Missing required configuration on your environment variables.\nThe missing env-vars are:${invalidKeys}`);
     }
 };
 

package/src/index.js

@@ -42,11 +42,12 @@ const getInternalAPI = () => {
 };
 
 const getOpenAPI = () => {
+    const accounts = require('./saas/openapi/accounts/accounts.setup');
     const tabs = require('./saas/openapi/tabs/tabs.setup');
     const contractors = require('./saas/openapi/contractors/contractors.setup');
     const projects = require('./saas/openapi/projects/projects.setup');
     const requirements = require('./saas/openapi/requirements');
-    const openAPI = { tabs, contractors, projects, requirements };
+    const openAPI = { accounts, tabs, contractors, projects, requirements };
     return openAPI;
 
 };

package/src/saas/internal-api/accounts/api/core/accounts.core.setup.js

@@ -4,7 +4,6 @@ const CreateAccountModel = require('../../models/core/create.account.model');
 const { validateType } = require('../../../../../common/validations/typeValidations');
 
 const { accountCreationSecret } = env.getEnv();
-const { NotFoundError } = require('../../../../../common/exceptions/notFoundError');
 
 const createAccount = async (createAccountModel, context) => {
     validateType(createAccountModel, CreateAccountModel);
@@ -46,7 +45,8 @@ const getAccountId = async (accountName, context) => {
     const account = await getAccount(accountName, context);
 
     if (!account) {
-        throw new NotFoundError(`Account ${accountName} does not exist`);
+        console.error(`Account ${accountName} does not exist`);
+        return null;
     }
 
     return account.userId;

package/src/saas/internal-api/accounts/api/openapi/accounts.openapi.api.js

@@ -3,30 +3,46 @@ const { backendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
     createApiKey: `${backendUrl}/saas/api-keys`,
-    initializeApiKeyOnAws: `${backendUrl}/saas/api-keys/aws`,
-    getApiKeyByAccountId: accountId => `${backendUrl}/saas/accounts/${accountId}/api-keys`,
-    getApiKeyDetails: `${backendUrl}/saas/api-keys`,
-    removeApiKey: `${backendUrl}/saas/api-keys`
+    getStaticApiKeyByAccountId: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
+    getApiKeyByKeyValue: `${backendUrl}/saas/api-keys`,
+    removeStaticApiKey: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
+    dynamicApiKey: accountId =>`${backendUrl}/saas/accounts/${accountId}/dynamic-api-key`
 };
 
-const createApiKey = async (data, context) => {
+const createStaticApiKey = async (data, context) => {
     return requests.postRequestHandler(Endpoints.createApiKey, data, context).then(res => res.data);
 };
 
-const initializeApiKeyOnAws = async (data, context) => {
-    return requests.postRequestHandler(Endpoints.initializeApiKeyOnAws, data, context).then(res => res.data);
+const createGeneratorApiKey = async (data, context) => {
+    return requests.postRequestHandler(Endpoints.createApiKey, data, context).then(res => res.data);
 };
 
-const getApiKeyByAccountId = async (accountId, context) => {
-    return requests.getRequestHandler(Endpoints.getApiKeyByAccountId(accountId), {}, context).then(res => res.data);
+const getStaticApiKeyByAccountId = async (accountId, context) => {
+    return requests.getRequestHandler(Endpoints.getStaticApiKeyByAccountId(accountId), {}, context).then(res => res.data);
 };
 
 const getApiKeyDetails = async (apiKeyValue, context) => {
-    return requests.getRequestHandler(Endpoints.getApiKeyDetails, { apiKeyValue }, context).then(res => res.data);
+    return requests.getRequestHandler(Endpoints.getApiKeyByKeyValue, { apiKeyValue }, context).then(res => res.data);
+};
+
+const deleteStaticApiKey = async (accountId, context) => {
+    return requests.deleteRequestHandler(Endpoints.removeStaticApiKey(accountId), context).then(res=>res.data);
 };
 
-const deleteApiKey = async (data, context) => {
-    return requests.deleteRequestHandler(Endpoints.removeApiKey, context, {}, {}, data);
+const deleteDynamicApiKey = async (accountId, context) => {
+    return requests.deleteRequestHandler(Endpoints.dynamicApiKey(accountId), context).then(res => res.data);
 };
 
-module.exports = { createApiKey, getApiKeyByAccountId, getApiKeyDetails, deleteApiKey, initializeApiKeyOnAws };
+const makeDynamicApiKeyExpired = async (accountId, context) => {
+    return requests.patchRequestHandler(Endpoints.dynamicApiKey(accountId), context, {}).then(res => res.data);
+};
+
+module.exports = {
+    createStaticApiKey,
+    createGeneratorApiKey,
+    getStaticApiKeyByAccountId,
+    getApiKeyDetails,
+    makeDynamicApiKeyExpired,
+    deleteStaticApiKey,
+    deleteDynamicApiKey
+};

package/src/saas/internal-api/accounts/api/openapi/accounts.openapi.setup.js

@@ -5,45 +5,70 @@ const generateApiKeyValue = accountName => {
     return crypto.createHash('sha256').update(accountName).digest('base64');
 };
 
-const createApiKey = async (accountId, apiKeyValue, context) => {
-    const data = { apiKeyValue, accountId };
-    return accountsAPI.createApiKey(data, context);
+const createStaticApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'ACCOUNT_STATIC', apiKeyName = null } = {}) => {
+    const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
+    return accountsAPI.createStaticApiKey(data, context);
 };
 
-const initializeApiKeyOnAws = async (accountId, apiKeyValue, context) => {
-    const data = { apiKeyValue, accountId };
-    return accountsAPI.initializeApiKeyOnAws(data, context);
+const createGeneratorApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'GENERATOR', apiKeyName = null } = {}) => {
+    const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
+    return accountsAPI.createGeneratorApiKey(data, context);
 };
 
-const getApiKeyByAccountId = async (accountId, context) => {
-    return accountsAPI.getApiKeyByAccountId(accountId, context);
+const getStaticApiKeyByAccountId = async (accountId, context) => {
+    return accountsAPI.getStaticApiKeyByAccountId(accountId, context);
 };
 
 const getApiKeyDetails = async (apiKeyValue, context) => {
     return accountsAPI.getApiKeyDetails(apiKeyValue, context);
 };
 
-const deleteApiKey = async (apiKeyValue, context) => {
-    const data = { apiKeyValue };
-    return accountsAPI.deleteApiKey(data, context);
+const deleteStaticApiKey = async (accountId, context) => {
+    return accountsAPI.deleteStaticApiKey(accountId, context);
 };
 
-const getOrCreateApiKey = async (accountId, apiKey, context) => {
-    const existingApiKey = await getApiKeyByAccountId(accountId, context);
+const getOrCreateStaticApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'ACCOUNT_STATIC', apiKeyName = null } = {}) => {
+    let existingApiKey = await getStaticApiKeyByAccountId(accountId, context);
+
+    if (existingApiKey.apiKeyValue) {
+        return existingApiKey;
+    }
+
+    existingApiKey = await getApiKeyDetails(apiKeyValue, context);
 
     if (!existingApiKey.apiKeyValue) {
-        return createApiKey(accountId, apiKey, context);
+        return createStaticApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
     }
 
     return existingApiKey;
 };
 
+const getOrCreateGeneratorApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'GENERATOR', apiKeyName = null } = {}) => {
+    const existingApiKey = await getApiKeyDetails(apiKeyValue, context);
+
+    if (!existingApiKey.apiKeyValue) {
+        return createGeneratorApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
+    }
+
+    return existingApiKey;
+};
+
+const deleteDynamicApiKey= async (accountId, context) => {
+    return accountsAPI.deleteDynamicApiKey(accountId, context);
+};
+
+const makeDynamicApiKeyExpired= async (accountId, context) => {
+    return accountsAPI.makeDynamicApiKeyExpired(accountId, context);
+};
+
 module.exports = {
-    createApiKey,
-    getApiKeyByAccountId,
+    createStaticApiKey,
+    generateApiKeyValue,
+    getOrCreateStaticApiKey,
+    getOrCreateGeneratorApiKey,
+    getStaticApiKeyByAccountId,
     getApiKeyDetails,
-    deleteApiKey,
-    getOrCreateApiKey,
-    initializeApiKeyOnAws,
-    generateApiKeyValue
-};
+    makeDynamicApiKeyExpired,
+    deleteStaticApiKey,
+    deleteDynamicApiKey
+};

package/src/saas/internal-api/common/requests.js

@@ -1,4 +1,5 @@
 const axios = require('axios');
+const errorValidation = require('../../../common/validations/errorValidation');
 
 const getRequestHandler = async (url, params = {}, context = null, headers = {}) => {
     enrichCookie(headers, context);
@@ -6,8 +7,8 @@ const getRequestHandler = async (url, params = {}, context = null, headers = {})
         const response = await axios.get(url, { params, headers });
         return response;
     } catch (error) {
-        const message = error.response.data && JSON.stringify(error.response.data) || error.message;
-        throw Error(message);
+        errorValidation.validateError(error);
+        return error.response;
     }
 
 };
@@ -18,8 +19,8 @@ const postRequestHandler = async (url, body, context = null, headers = {}, param
         const response = await axios.post(url, body, { headers, params });
         return response;
     } catch (error) {
-        const message = error.response.data && JSON.stringify(error.response.data) || error.message;
-        throw Error(message);
+        errorValidation.validateError(error);
+        return error.response;
     }
 
 };
@@ -30,8 +31,20 @@ const putRequestHandler = async (url, body, context = null, headers = {}) => {
         const response = await axios.put(url, body, { headers });
         return response;
     } catch (error) {
-        const message = error.response.data && JSON.stringify(error.response.data) || error.message;
-        throw Error(message);
+        errorValidation.validateError(error);
+        return error.response;
+    }
+
+};
+
+const patchRequestHandler = async (url, context, body, headers = {}) => {
+    enrichCookie(headers, context);
+    try {
+        const response = await axios.patch(url, body, { headers });
+        return response;
+    } catch (error) {
+        errorValidation.validateError(error);
+        return error.response;
     }
 
 };
@@ -42,8 +55,8 @@ const deleteRequestHandler = async (url, context = null, headers = {}, params =
         const response = await axios.delete(url, { params, headers, data });
         return response;
     } catch (error) {
-        const message = error.response.data && JSON.stringify(error.response.data) || error.message;
-        throw Error(message);
+        errorValidation.validateError(error);
+        return error.response;
     }
 
 };
@@ -54,4 +67,10 @@ const enrichCookie = (headers, context) => {
     }
 };
 
-module.exports = { getRequestHandler, postRequestHandler, putRequestHandler, deleteRequestHandler };
+module.exports = {
+    getRequestHandler,
+    postRequestHandler,
+    putRequestHandler,
+    patchRequestHandler,
+    deleteRequestHandler
+};

package/src/saas/internal-api/compliance/api/coverage/coverage.api.js

@@ -1,4 +1,4 @@
-const requests = require('../../../common/requests');
+const requests = require('../../../../openapi/common/requests');
 const { nodeBackendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
@@ -6,12 +6,12 @@ const Endpoints = {
     getCoverageByCoiId: coiId => `${nodeBackendUrl}/coverage/${coiId}`
 };
 
-const saveCoverage = async (coverage, context) => {
-    return requests.postRequestHandler(Endpoints.saveCoverage, coverage, context);
+const saveCoverage = async (coverage, nodeBackendSecret) => {
+    return requests.postRequestHandler(Endpoints.saveCoverage, nodeBackendSecret, coverage);
 };
 
-const getCoverageByCoiId = async (coiId, context) => {
-    return requests.getRequestHandler(Endpoints.getCoverageByCoiId(coiId), {}, context);
+const getCoverageByCoiId = async (coiId, nodeBackendSecret) => {
+    return requests.getRequestHandler(Endpoints.getCoverageByCoiId(coiId), nodeBackendSecret);
 };
 
 module.exports = { saveCoverage, getCoverageByCoiId };

package/src/saas/internal-api/compliance/api/coverage/coverage.setup.js

@@ -1,11 +1,11 @@
 const coverageApi = require('./coverage.api');
 
-const saveCoverage = async (coverage, context) => {
-    return coverageApi.saveCoverage(coverage, context);
+const saveCoverage = async (coverage, nodeBackendSecret) => {
+    return coverageApi.saveCoverage(coverage, nodeBackendSecret);
 };
 
-const getCoverageByCoiId = async (coiId, context) => {
-    return coverageApi.getCoverageByCoiId(coiId, context).then(res => res && res.data);
+const getCoverageByCoiId = async (coiId, nodeBackendSecret) => {
+    return coverageApi.getCoverageByCoiId(coiId, nodeBackendSecret).then(res => res && res.data);
 };
 
 module.exports = { saveCoverage, getCoverageByCoiId };

package/src/saas/internal-api/contractors/api/contractors.api.js

@@ -9,11 +9,12 @@ const Endpoints = {
     archive: contractorId => `${backendUrl}/saas/contractor/${contractorId}/archive`,
     restore: contractorId => `${backendUrl}/saas/contractor/${contractorId}/restore`,
     edit: contractorId => `${backendUrl}/saas/contractors/${contractorId}/update`,
-    updateVendorExpiryDate: contractorId => `${backendUrl}/_saas/automation/contractor/${contractorId}/expiry-date`
+    updateVendorExpiryDate: contractorId => `${backendUrl}/_saas/automation/contractor/${contractorId}/expiry-date`,
+    assignMptToProperties: (accountId, tenantId) => `${backendUrl}/saas/account/${accountId}/multi-properties/${tenantId}`
 };
 
 const createContractors = async (createContractorModel, context) => {
-    return requests.postRequestHandler(Endpoints.create, createContractorModel, context).then(res => res.data);
+    return requests.postRequestHandler(Endpoints.create, createContractorModel, context).then(res => res.data || res);
 };
 
 const getContractorsByAccountId = async (params, context) => {
@@ -46,6 +47,24 @@ const updateExpiryDate = async (contractorId, expiryDate, policyName) => {
     return requests.postRequestHandler(Endpoints.updateVendorExpiryDate(contractorId), data);
 };
 
+const assignMptToProperties = async (assignToMptModel, context) => {
+    const params = { updateInfoUser: 'EditVendor' };
+    const response = await requests.postRequestHandler(
+        Endpoints.assignMptToProperties(assignToMptModel.accountId, assignToMptModel.tenantId),
+        assignToMptModel.properties,
+        context,
+        {},
+        params
+    );
+    return response;
+};
+
+const getContractorsByTabId = async (tabId, activityStatus, context) => {
+    const body = { tabId, activityStatus };
+    const response = await requests.postRequestHandler(Endpoints.get, body, context);
+    return response.data;
+};
+
 module.exports = {
     createContractors,
     getContractorsByAccountId,
@@ -54,5 +73,7 @@ module.exports = {
     archiveByContractorId,
     restoreByContractorId,
     editContractor,
-    updateExpiryDate
+    updateExpiryDate,
+    assignMptToProperties,
+    getContractorsByTabId
 };

package/src/saas/internal-api/contractors/api/contractors.setup.js

@@ -1,8 +1,7 @@
 const contractorsAPI = require('./contractors.api');
 const { CreateContractorModel } = require('../models/create.contractor.model');
-const { ContractorModel } = require('../models/edit.contractor.model');
+const { ContractorModel, MptModel } = require('../models/edit.contractor.model');
 const { validateType } = require('../../../../common/validations/typeValidations');
-const requests = require('../../common/requests');
 
 const createContractors = async (createContractorsModel, context) => {
     validateType(createContractorsModel, CreateContractorModel);
@@ -33,15 +32,24 @@ const restoreByContractorId = (contractorId, context) => {
     return contractorsAPI.restoreByContractorId(contractorId, context);
 };
 
-const editContractor = async (editContractorModel, context) => {
+const editContractor = (editContractorModel, context) => {
     validateType(editContractorModel, ContractorModel);
     return contractorsAPI.editContractor(editContractorModel, context);
 };
 
-const updateExpiryDate = async (contractorId, expiryDate, policyName) => {
+const updateExpiryDate = (contractorId, expiryDate, policyName) => {
     return contractorsAPI.updateExpiryDate(contractorId, expiryDate, policyName);
 };
 
+const getContractorsByTabId = (tabId, context, activityStatus = 'ACTIVE') => {
+    return contractorsAPI.getContractorsByTabId(tabId, activityStatus, context);
+};
+
+const assignMptToProperties = (assignToMptModel, context) => {
+    validateType(assignToMptModel, MptModel);
+    return contractorsAPI.assignMptToProperties(assignToMptModel, context);
+};
+
 module.exports = {
     createContractors,
     getContractorsByAccountId,
@@ -50,5 +58,7 @@ module.exports = {
     archiveByContractorId,
     restoreByContractorId,
     editContractor,
-    updateExpiryDate
+    updateExpiryDate,
+    getContractorsByTabId,
+    assignMptToProperties
 };

package/src/saas/internal-api/contractors/models/create.contractor.model.js

@@ -1,11 +1,12 @@
 const { validateType } = require('../../../../common/validations/typeValidations');
 
-function CreateContractorModel(requirementId, inviterEmail, vendorsInfo) {
+function CreateContractorModel(requirementId, inviterEmail, vendorsInfo, { tabId = null } = {}) {
     this.reqId = requirementId;
     this.inviterEmail = inviterEmail;
     this.vendorInfo = vendorsInfo;
     this.disableMail = true;
     this.sendCovid19Form = false;
+    this.tabId = tabId;
 
     validateType(vendorsInfo, Array);
     vendorsInfo && validateType(vendorsInfo[0], ContractorInfo);

package/src/saas/internal-api/contractors/models/edit.contractor.model.js

@@ -1,15 +1,56 @@
 const { validateType } = require('../../../../common/validations/typeValidations');
 
-function ContractorModel(contractorId, company, emailAddress, tab, tenantRecord, additionalEmails) {
+function ContractorModel(contractorId, company, emailAddress, tab, additionalDetails ) {
+    validateType(tab, VendorTabModel);
+    validateType(additionalDetails, ContractorDetailsModel);
+
     this.contractorId = contractorId;
     this.company = company;
     this.emailAddress = emailAddress;
     this.tab = tab;
-    this.tenantRecord = tenantRecord;
+
+    for (const detail in additionalDetails) {
+        if (additionalDetails[detail]){
+            this[detail] = additionalDetails[detail];
+        }
+    }
+
+}
+
+function ContractorDetailsModel({
+    additionalEmails = [],
+    dba = null,
+    firstName = null,
+    lastName = null,
+    address = null,
+    city = null,
+    state = null,
+    zipCode = null,
+    phoneNumber = null,
+    agreementNumber = null,
+    projectDescription = null,
+    startDate = null,
+    endDate = null,
+    tenantRecord = {}
+} = {}){
     this.additionalEmails = additionalEmails;
+    this.dba = dba;
+    this.fName = firstName;
+    this.lName = lastName;
+    this.location = address;
+    this.city = city;
+    this.state = state;
+    this.zipCode = zipCode;
+    this.phoneNumber = phoneNumber;
+    this.recordId = agreementNumber;
+    this.descriptionOfOperations = projectDescription;
+    this.startDate = startDate;
+    this.endDate = endDate;
 
-    validateType(tenantRecord, TenantRecordModel);
-    validateType(tab, VendorTabModel);
+    if (tenantRecord && Object.keys(tenantRecord).length > 0){
+        validateType(tenantRecord, TenantRecordModel);
+        this.tenantRecord = tenantRecord;
+    }
 }
 
 function TenantRecordModel(id, companyName, emailAddress) {
@@ -22,4 +63,18 @@ function VendorTabModel(type){
     this.type = type;
 }
 
-module.exports = { ContractorModel, TenantRecordModel, VendorTabModel };
+class MptModel {
+    constructor(accountId, tenantId, properties) {
+        this.accountId = accountId;
+        this.tenantId = tenantId;
+        this.properties = properties;
+    }
+}
+
+module.exports = {
+    ContractorModel,
+    TenantRecordModel,
+    VendorTabModel,
+    ContractorDetailsModel,
+    MptModel
+};

package/src/saas/internal-api/projects/api/core/projects.api.js

@@ -4,7 +4,9 @@ const { backendUrl } = require('../../../../../env').getEnv();
 const Endpoints = {
     create: `${backendUrl}/saas/project`,
     delete: projectId => `${backendUrl}/saas/project/${projectId}`,
-    getByAccountId: `${backendUrl}/saas/project/list`
+    getByAccountId: `${backendUrl}/saas/project/list`,
+    update: `${backendUrl}/saas/project`,
+    getProjectByProjectId: projectId => `${backendUrl}/saas/project/${projectId}`
 };
 
 const create = async (project, context) => {
@@ -16,8 +18,17 @@ const getProjectsByAccountId = async (accountId, context) => {
     return requests.getRequestHandler(Endpoints.getByAccountId, params, context).then(res => res.data);
 };
 
+const getProjectByProjectId = async (projectId, context) => {
+    const params = { };
+    return requests.getRequestHandler(Endpoints.getProjectByProjectId(projectId), params, context).then(res => res.data);
+};
+
 const deleteProjectById = async (projectId, context) => {
     return requests.deleteRequestHandler(Endpoints.delete(projectId), context);
 };
 
-module.exports = { create, getProjectsByAccountId, deleteProjectById };
+const update = async (project, context) => {
+    return requests.postRequestHandler(Endpoints.update, project, context);
+};
+
+module.exports = { create, getProjectsByAccountId, deleteProjectById, update, getProjectByProjectId };

package/src/saas/internal-api/projects/api/core/projects.setup.js

@@ -2,6 +2,7 @@ const projectsApi = require('./projects.api');
 const accounts = require('../../../accounts/api/core/accounts.core.setup');
 const { validateType } = require('../../../../../common/validations/typeValidations');
 const CreateProjectModel = require('../../models/core/create.project.model');
+const UpdateProjectModel = require('../../models/core/update.project.model');
 
 const getProjectsByAccountName = async (accountName, context) => {
     const accountId = accounts.getAccountId(accountName, context);
@@ -12,6 +13,10 @@ const getProjectsByAccountId = async (accountId, context) => {
     return projectsApi.getProjectsByAccountId(accountId, context);
 };
 
+const getProjectByProjectId = async (projectId, context) => {
+    return projectsApi.getProjectByProjectId(projectId, context);
+};
+
 const getProjectsByName = async (accountId, projectName, context) => {
     const projects = await getProjectsByAccountId(accountId, context);
     const filteredProjects = projects.filter(project => project.projectName === projectName);
@@ -38,10 +43,18 @@ const getOrCreateProject = async (createProjectModel, context) => {
     return createProject(createProjectModel, context);
 };
 
+const updateProject = async (updateProjectModel, context) => {
+    validateType(updateProjectModel, UpdateProjectModel);
+    return projectsApi.update(updateProjectModel, context);
+};
+
 module.exports = {
     getProjectsByAccountName,
     getProjectsByAccountId,
     createProject,
     deleteProjectByName,
-    getOrCreateProject
+    getOrCreateProject,
+    updateProject,
+    getProjectsByName,
+    getProjectByProjectId
 };

package/src/saas/internal-api/projects/index.js

@@ -1,9 +1,10 @@
 const projectService = require('./api/core/projects.setup');
 const projectSettingsService = require('./api/settings/project.settings.setup');
 const CreateProjectModel = require('./models/core/create.project.model');
+const UpdateProjectModel = require('./models/core/update.project.model');
 const UpdateProjectSettingsModel = require('./models/settings/update.project.settings.model');
 
-const coreModels = { CreateProjectModel };
+const coreModels = { CreateProjectModel, UpdateProjectModel };
 const settingsModels = { UpdateProjectSettingsModel };
 
 const services = {

package/src/saas/internal-api/projects/models/core/create.project.model.js

@@ -3,7 +3,7 @@ function CreateProjectModel(accountId, name, description, address, number, start
     tenantSolutionEnabled = 0, onboardingEnabled = 0, automaticRenewalEnabled = 0) {
     this.projectName = name;
     this.userId = accountId;
-    this.projectDescription = description;
+    this.regionOrDivision = description;
 
     this.address = address;
     this.projectNumber = number;

package/src/saas/internal-api/projects/models/core/update.project.model.js

@@ -0,0 +1,27 @@
+function UpdateProjectModel(accountId, projectId, name, description, address, number, startDate, endDate,
+    city, state, zipCode, companyNameForProject, certificateHolder = '', additionalInsured = '',
+    tenantSolutionEnabled = 0, onboardingEnabled = 0, automaticRenewalEnabled = 0) {
+    this.projectId = projectId;
+    this.projectName = name;
+    this.userId = accountId;
+    this.regionOrDivision = description;
+
+    this.address = address;
+    this.projectNumber = number;
+    this.projectStartDate = startDate;
+    this.projectEndDate = endDate;
+
+    this.city = city;
+    this.state = state;
+    this.zipCode = zipCode;
+    this.companyNameForProject = companyNameForProject;
+
+    this.certificateHolder = certificateHolder;
+    this.additionalInsured = additionalInsured;
+
+    this.tenantSolutionEnabled = tenantSolutionEnabled;
+    this.onboardingEnabled = onboardingEnabled;
+    this.automaticRenewalEnabled = automaticRenewalEnabled;
+}
+
+module.exports = UpdateProjectModel;

package/src/saas/internal-api/tabs/api/tabs.setup.js

@@ -14,7 +14,7 @@ const getTabsByProjectId = async (projectId, context) => {
     return tabsAPI.getTabsByProjectId(projectId, context);
 };
 
-const getTabsByName = async (projectId, tabName, context,{ tabType }={}) => {
+const getTabsByName = async (projectId, tabName, context, { tabType } = {}) => {
     const tabs = await tabsAPI.getTabsByProjectId(projectId, context);
     const requestedTab = tabType?
         tabs.find(tab => tab.tabName === tabName && tab.type === tabType):

package/src/saas/openapi/accounts/accounts.api.js

@@ -0,0 +1,17 @@
+const requests = require('../common/requests');
+const { openapiUrl } = require('../../../env').getEnv();
+
+const Endpoints = {
+    getAccountList: `${openapiUrl}/accounts`,
+    dynamicApiKey: accountId =>`${openapiUrl}/accounts/${accountId}/dynamic-api-key`
+};
+
+const getAccountList = async apiKey => {
+    return requests.getRequestHandler(Endpoints.getAccountList, apiKey).then(res => res.data);
+};
+
+const generateDynamicApiKey = async (accountId, masterApiKey) => {
+    return requests.getRequestHandler(Endpoints.dynamicApiKey(accountId), masterApiKey).then(res => res.data);
+};
+
+module.exports = { getAccountList, generateDynamicApiKey };

package/src/saas/openapi/accounts/accounts.setup.js

@@ -0,0 +1,11 @@
+const accountsApi = require('./accounts.api');
+
+const getAccountList = async apiKey => {
+    return accountsApi.getAccountList(apiKey);
+};
+
+const generateDynamicApiKey= async (accountId, masterApiKey) => {
+    return accountsApi.generateDynamicApiKey(accountId, masterApiKey);
+};
+
+module.exports = { getAccountList,generateDynamicApiKey };

package/src/saas/openapi/common/requests.js

@@ -1,4 +1,5 @@
 const axios = require('axios');
+const errorValidation = require('../../../common/validations/errorValidation');
 
 const getRequestHandler = async (url, apiKey, params = {}, headers = {}) => {
     enrichApiKey(headers, apiKey);
@@ -6,8 +7,8 @@ const getRequestHandler = async (url, apiKey, params = {}, headers = {}) => {
         const response = await axios.get(url, { params, headers });
         return response;
     } catch (error) {
-        const message = error.response.data && JSON.stringify(error.response.data) || error.message;
-        throw Error(message);
+        errorValidation.validateError(error);
+        return error.response;
     }
 
 };
@@ -18,8 +19,8 @@ const postRequestHandler = async (url, apiKey, body, headers = {}) => {
         const response = await axios.post(url, body, { headers });
         return response;
     } catch (error) {
-        const message = error.response.data && JSON.stringify(error.response.data) || error.message;
-        throw Error(message);
+        errorValidation.validateError(error);
+        return error.response;
     }
 
 };
@@ -30,8 +31,8 @@ const putRequestHandler = async (url, apiKey, body, headers = {}) => {
         const response = await axios.put(url, body, { headers });
         return response;
     } catch (error) {
-        const message = error.response.data && JSON.stringify(error.response.data) || error.message;
-        throw Error(message);
+        errorValidation.validateError(error);
+        return error.response;
     }
 
 };
@@ -42,8 +43,8 @@ const patchRequestHandler = async (url, apiKey, body, headers = {}) => {
         const response = await axios.patch(url, body, { headers });
         return response;
     } catch (error) {
-        const message = error.response.data && JSON.stringify(error.response.data) || error.message;
-        throw Error(message);
+        errorValidation.validateError(error);
+        return error.response;
     }
 
 };
@@ -54,8 +55,8 @@ const deleteRequestHandler = async (url, apiKey, headers = {}, params = {}, data
         const response = await axios.delete(url, { params, headers, data });
         return response;
     } catch (error) {
-        const message = error.response.data && JSON.stringify(error.response.data) || error.message;
-        throw Error(message);
+        errorValidation.validateError(error);
+        return error.response;
     }
 
 };

package/src/saas/openapi/projects/projects.api.js

@@ -6,7 +6,9 @@ const Endpoints = {
     getAllProjects: `${openapiUrl}/properties/all`,
     getModifiedProjects: `${openapiUrl}/properties/modified`,
     createProject: `${openapiUrl}/properties`,
-    updateProject: projectId => `${openapiUrl}/properties/${projectId}`
+    updateProject: projectId => `${openapiUrl}/properties/${projectId}`,
+    getProjectSettings: projectId => `${openapiUrl}/properties/${projectId}/settings`,
+    updateProjectSettings: projectId => `${openapiUrl}/properties/${projectId}/settings`
 };
 
 const getProjectsByName = async (apiKey, params) => {
@@ -29,10 +31,22 @@ const updateProject = async (apiKey, projectId, projectData) => {
     return requests.patchRequestHandler(Endpoints.updateProject(projectId), apiKey, projectData).then(res => res.data);
 };
 
+const updateProjectSettings = async (apiKey, projectId, projectSettings) => {
+    return requests.patchRequestHandler(Endpoints.updateProjectSettings(projectId),
+        apiKey, projectSettings).then(res => res.data);
+};
+
+const getProjectSettings = async (apiKey, projectId) => {
+    return requests.getRequestHandler(Endpoints.getProjectSettings(projectId),
+        apiKey).then(res => res.data);
+};
+
 module.exports = {
     getProjectsByName,
     getAllProjects,
     getModifiedProjects,
     createProject,
-    updateProject
+    updateProject,
+    updateProjectSettings,
+    getProjectSettings
 };

package/src/saas/openapi/projects/projects.setup.js

@@ -20,10 +20,20 @@ const getModifiedProjects = async (apiKey, timestamp) => {
     return projectsApi.getModifiedProjects(apiKey, { timestamp });
 };
 
+const updateProjectSettings = async (apiKey, projectId, projectSettings) => {
+    return projectsApi.updateProjectSettings(apiKey, projectId, projectSettings);
+};
+
+const getProjectSettings = async (apiKey, projectId) => {
+    return projectsApi.getProjectSettings(apiKey, projectId);
+};
+
 module.exports = {
     getProjectsByName,
     createProject,
     updateProject,
     getAllProjects,
-    getModifiedProjects
+    getModifiedProjects,
+    updateProjectSettings,
+    getProjectSettings
 };

package/src/common/exceptions/notFoundError.js

@@ -1,10 +0,0 @@
-const { StatusCodes } = require('http-status-code');
-
-class NotFoundError extends Error {
-    constructor(message) {
-        const { NOT_FOUND } = StatusCodes;
-        super(message, NOT_FOUND);
-    }
-}
-
-module.exports = { NotFoundError };