@getjones/test-infra 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getjones/test-infra",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Providing internal and openapi interface",
   "main": "src/index.js",
   "scripts": {
@@ -19,9 +19,10 @@
     "mocha": "^8.3.2"
   },
   "devDependencies": {
-    "eslint": "^7.22.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-node": "^11.1.0"
+    "babel-eslint": "^10.0.3",
+    "eslint": "^6.8.0",
+    "eslint-plugin-import": "^2.19.1",
+    "mocha-spec-json-output-reporter": "^1.1.7"
   },
   "directories": {
     "test": "tests"

package/src/common/validations/errorValidation.js

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

package/src/env.js

@@ -1,44 +1,44 @@
 let privateMembers = {
-    backendUrl: null,
-    openapiUrl: null,
-    nodeBackendUrl: null,
-    credentials: null,
-    environment: null,
-    accountCreationSecret: null,
-    threadSchedulerSecret: null,
-    nodeBackendSecret: null
+	backendUrl: null,
+	openapiUrl: null,
+	nodeBackendUrl: null,
+	credentials: null,
+	environment: null,
+	accountCreationSecret: null,
+	threadSchedulerSecret: null,
+	nodeBackendSecret: null
 };
 
 const init = conf => {
-    privateMembers = Object.assign(privateMembers, conf);
-    requiredValidation({
-        backendUrl: privateMembers.backendUrl,
-        openapiUrl: privateMembers.openapiUrl,
-        nodeBackendUrl: privateMembers.nodeBackendUrl,
-        environment: privateMembers.environment
-    });
+	privateMembers = Object.assign(privateMembers, conf);
+	requiredValidation({
+		backendUrl: privateMembers.backendUrl,
+		openapiUrl: privateMembers.openapiUrl,
+		nodeBackendUrl: privateMembers.nodeBackendUrl,
+		environment: privateMembers.environment
+	});
 };
 
 const requiredValidation = object => {
-    const invalidKeys = [];
-    Object.keys(object).forEach(key => {
-        if (!object[key]) {
-            invalidKeys.push(` '${key}'`);
-        }
-    });
+	const invalidKeys = [];
+	Object.keys(object).forEach(key => {
+		if (!object[key]) {
+			invalidKeys.push(` '${key}'`);
+		}
+	});
 
-    if (invalidKeys.length > 0) {
-        throw Error(`Missing required configuration on your environment variables.\nThe missing env-vars are:${invalidKeys}`);
-    }
+	if (invalidKeys.length > 0) {
+		throw Error(`Missing required configuration on your environment variables.\nThe missing env-vars are:${invalidKeys}`);
+	}
 };
 
 const isLocalhost = () => {
-    return privateMembers.backendUrl.includes('localhost');
+	return privateMembers.backendUrl.includes('localhost');
 };
 
 module.exports = {
-    init,
-    getEnv: () => privateMembers,
-    requiredValidation,
-    isLocalhost
+	init,
+	getEnv: () => privateMembers,
+	requiredValidation,
+	isLocalhost
 };

package/src/index.js

@@ -1,55 +1,54 @@
 const env = require('./env');
 
 const init = conf => {
-    env.init(conf);
-    const internalAPI = getInternalAPI();
-    const openAPI = getOpenAPI();
-    const threadScheduler = require('./saas/thread-scheduler/runner');
+	env.init(conf);
+	const internalAPI = getInternalAPI();
+	const openAPI = getOpenAPI();
+	const threadScheduler = require('./saas/thread-scheduler/runner');
 
-    return { internalAPI, openAPI, threadScheduler };
+	return { internalAPI, openAPI, threadScheduler };
 };
 
 const getInternalAPI = () => {
-    const auth = require('./saas/internal-api/auth');
-    const accounts = require('./saas/internal-api/accounts');
-
-    const projects = require('./saas/internal-api/projects');
-    const tabs = require('./saas/internal-api/tabs');
-
-    const requirements = require('./saas/internal-api/requirements');
-    const contractors = require('./saas/internal-api/contractors');
-
-    const coi = require('./saas/internal-api/coi');
-    const compliance = require('./saas/internal-api/compliance');
-    const users = require('./saas/internal-api/users');
-
-    const reports = require('./saas/internal-api/reports');
-
-    const internalAPI = {
-        auth,
-        accounts,
-        projects,
-        tabs,
-        requirements,
-        contractors,
-        coi,
-        compliance,
-        reports,
-        users,
-    };
-
-    return internalAPI;
+	const auth = require('./saas/internal-api/auth');
+	const accounts = require('./saas/internal-api/accounts');
+
+	const projects = require('./saas/internal-api/projects');
+	const tabs = require('./saas/internal-api/tabs');
+
+	const requirements = require('./saas/internal-api/requirements');
+	const contractors = require('./saas/internal-api/contractors');
+
+	const coi = require('./saas/internal-api/coi');
+	const compliance = require('./saas/internal-api/compliance');
+	const users = require('./saas/internal-api/users');
+
+	const reports = require('./saas/internal-api/reports');
+
+	const internalAPI = {
+		auth,
+		accounts,
+		projects,
+		tabs,
+		requirements,
+		contractors,
+		coi,
+		compliance,
+		reports,
+		users
+	};
+
+	return internalAPI;
 };
 
 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 = { accounts, tabs, contractors, projects, requirements };
-    return openAPI;
-
+	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 = { accounts, tabs, contractors, projects, requirements };
+	return openAPI;
 };
 
 module.exports = init;

package/src/saas/internal-api/accounts/models/settings/update.settings.model.js

@@ -1,8 +1,7 @@
 function UpdateAccountSettings(accountId, isMultiPropertyTenants, isHighPriority) {
-    this.accountId = accountId;
-    this.isMultiPropertyTenants = isMultiPropertyTenants;
-    this.isHighPriority = isHighPriority;
+	this.accountId = accountId;
+	this.isMultiPropertyTenants = isMultiPropertyTenants;
+	this.isHighPriority = isHighPriority;
 }
 
 module.exports = UpdateAccountSettings;
-

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

@@ -2,75 +2,70 @@ const axios = require('axios');
 const errorValidation = require('../../../common/validations/errorValidation');
 
 const getRequestHandler = async (url, params = {}, context = null, headers = {}) => {
-    enrichCookie(headers, context);
-    try {
-        const response = await axios.get(url, { params, headers });
-        return response;
-    } catch (error) {
-        errorValidation.validateError(error);
-        return error.response;
-    }
-
+	enrichCookie(headers, context);
+	try {
+		const response = await axios.get(url, { params, headers });
+		return response;
+	} catch (error) {
+		errorValidation.validateError(error);
+		return error.response;
+	}
 };
 
 const postRequestHandler = async (url, body, context = null, headers = {}, params = {}) => {
-    enrichCookie(headers, context);
-    try {
-        const response = await axios.post(url, body, { headers, params });
-        return response;
-    } catch (error) {
-        errorValidation.validateError(error);
-        return error.response;
-    }
-
+	enrichCookie(headers, context);
+	try {
+		const response = await axios.post(url, body, { headers, params });
+		return response;
+	} catch (error) {
+		errorValidation.validateError(error);
+		return error.response;
+	}
 };
 
 const putRequestHandler = async (url, body, context = null, headers = {}) => {
-    enrichCookie(headers, context);
-    try {
-        const response = await axios.put(url, body, { headers });
-        return response;
-    } catch (error) {
-        errorValidation.validateError(error);
-        return error.response;
-    }
-
+	enrichCookie(headers, context);
+	try {
+		const response = await axios.put(url, body, { headers });
+		return response;
+	} catch (error) {
+		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;
-    }
-
+	enrichCookie(headers, context);
+	try {
+		const response = await axios.patch(url, body, { headers });
+		return response;
+	} catch (error) {
+		errorValidation.validateError(error);
+		return error.response;
+	}
 };
 
 const deleteRequestHandler = async (url, context = null, headers = {}, params = {}, data = {}) => {
-    enrichCookie(headers, context);
-    try {
-        const response = await axios.delete(url, { params, headers, data });
-        return response;
-    } catch (error) {
-        errorValidation.validateError(error);
-        return error.response;
-    }
-
+	enrichCookie(headers, context);
+	try {
+		const response = await axios.delete(url, { params, headers, data });
+		return response;
+	} catch (error) {
+		errorValidation.validateError(error);
+		return error.response;
+	}
 };
 
 const enrichCookie = (headers, context) => {
-    if (context) {
-        headers.Cookie = context;
-    }
+	if (context) {
+		headers.Cookie = context;
+	}
 };
 
 module.exports = {
-    getRequestHandler,
-    postRequestHandler,
-    putRequestHandler,
-    patchRequestHandler,
-    deleteRequestHandler
-};
+	getRequestHandler,
+	postRequestHandler,
+	putRequestHandler,
+	patchRequestHandler,
+	deleteRequestHandler
+};

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

@@ -1,17 +1,27 @@
-const requests = require('../../../../openapi/common/requests');
-const { nodeBackendUrl } = require('../../../../../env').getEnv();
+const openApiRequests = require('../../../../openapi/common/requests');
+const internalApiRequests = require('../../../common/requests');
+const { backendUrl, nodeBackendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
-    saveCoverage: `${nodeBackendUrl}/coverage`,
+    saveCoverageNode: `${nodeBackendUrl}/coverage`,
+    saveCoverageJava: contractorId => `${backendUrl}/saas/contractors/${contractorId}/coverage`,
     getCoverageByCoiId: coiId => `${nodeBackendUrl}/coverage/${coiId}`
 };
 
-const saveCoverage = async (coverage, nodeBackendSecret) => {
-    return requests.postRequestHandler(Endpoints.saveCoverage, nodeBackendSecret, coverage);
+const saveCoverageNode = (coverage, nodeBackendSecret) => {
+    return openApiRequests.postRequestHandler(Endpoints.saveCoverageNode, nodeBackendSecret, coverage);
 };
 
-const getCoverageByCoiId = async (coiId, nodeBackendSecret) => {
-    return requests.getRequestHandler(Endpoints.getCoverageByCoiId(coiId), nodeBackendSecret);
+const saveCoverageJava = (auditorContext, contractorId, coverage) => {
+    return internalApiRequests.postRequestHandler(Endpoints.saveCoverageJava(contractorId), coverage, auditorContext);
 };
 
-module.exports = { saveCoverage, getCoverageByCoiId };
+const getCoverageByCoiId = (coiId, nodeBackendSecret) => {
+    return openApiRequests.getRequestHandler(Endpoints.getCoverageByCoiId(coiId), nodeBackendSecret);
+};
+
+module.exports = {
+    saveCoverageNode, 
+    saveCoverageJava, 
+    getCoverageByCoiId
+};

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

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

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

@@ -0,0 +1,53 @@
+class coverageRequestModel {
+    constructor({
+        coiId, 
+        documentsModel
+    }) {
+        this.coiId = coiId,
+        this.documents = documentsModel;
+    }
+}
+
+class coverageDocumentModel {
+    constructor({
+        documentType, 
+        pagesModel
+    }) {
+        this.documentType = documentType,
+        this.pagesModel = pagesModel;
+    }
+}
+
+class coveragePageModel {
+    constructor({
+        pageNumber, 
+        policies
+    }) {
+        this.pageNumber = pageNumber,
+        this.policies = policies;
+    }
+}
+
+class coveragePolicyModel {
+    constructor({
+        key, 
+        policyEntities,
+        provisions,
+        limits
+    }) {
+        this.key = key,
+        this.policyEntities = policyEntities,
+        this.provisions = provisions,
+        this.limits = limits
+    }
+}
+
+const documentTypesList = ['accord25']
+
+module.exports = {
+    coverageRequestModel,
+    coverageDocumentModel,
+    coveragePageModel,
+    coveragePolicyModel,
+    documentTypesList
+};

package/src/saas/internal-api/projects/api/settings/project.settings.setup.js

@@ -7,7 +7,7 @@ const updateProjectSettings = async (updateProjectSettingsModel, context) => {
     return updateProjectSettingsByProjectId(updateProjectSettingsModel, context);
 };
 
-const getProjectSettings = async (projectId, context)=>{
+const getProjectSettings = async (projectId, context) => {
     return getProjectSettingsByProjectId(projectId, context);
 };
 

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

@@ -1,6 +1,6 @@
 function UpdateProjectModel(accountId, projectId, name, description, address, number, startDate, endDate,
     city, state, zipCode, companyNameForProject, certificateHolder = '', additionalInsured = '',
-    tenantSolutionEnabled = 0, onboardingEnabled = 0, automaticRenewalEnabled = 0) {
+    tenantSolutionEnabled = 0, onboardingEnabled = 0, automaticRenewalEnabled = 0, onboardedVendors = 0) {
     this.projectId = projectId;
     this.projectName = name;
     this.userId = accountId;
@@ -10,6 +10,7 @@ function UpdateProjectModel(accountId, projectId, name, description, address, nu
     this.projectNumber = number;
     this.projectStartDate = startDate;
     this.projectEndDate = endDate;
+    this.onboardedVendors = onboardedVendors;
 
     this.city = city;
     this.state = state;

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

@@ -7,7 +7,8 @@ function UpdateProjectSettingsModel({
     onboardingPhase = false,
     projectId=null,
     qrEnabled = false,
-    tenantSolution = false
+    tenantSolution = false,
+    autocompleteAddVendors = defaultAutocompleteAddVendors,
 
 }) {
     this.autoGaps = autoGaps;
@@ -18,6 +19,7 @@ function UpdateProjectSettingsModel({
     this.projectId = projectId;
     this.qrEnabled = qrEnabled;
     this.tenantSolution = tenantSolution;
+    this.autocompleteAddVendors = autocompleteAddVendors;
 }
 
 module.exports = UpdateProjectSettingsModel;
@@ -25,10 +27,14 @@ module.exports = UpdateProjectSettingsModel;
 const defaultMarketplace = {
     marketplaceEnabled: false,
     marketplacePreApproved: false,
-    marketplacePublicLink: false
+    marketplaceOnboardedVendors:false
 };
 const defaultAutoGaps = {
     Guests: false,
     Tenants: false,
     Vendors: false
+};
+const defaultAutocompleteAddVendors = {
+    autocompleteAddVendorsForPm: false,
+    autocompleteAddVendorsForTenants: false,
 };

package/src/saas/internal-api/recordNotes/api/record.notes.api.js

@@ -0,0 +1,40 @@
+const requests = require('../../common/requests');
+const { backendUrl } = require('../../../../env').getEnv();
+
+const Endpoints = {
+    create: recordId => `${backendUrl}/saas/contractors/${recordId}/notes`,
+    getNotesByRecordId: recordId => `${backendUrl}/saas/contractors/${recordId}/notes`,
+    getNotesCountByRecordId: recordId => `${backendUrl}/saas/contractors/${recordId}/notes/count`,
+    deleteByNoteId: noteId => `${backendUrl}/saas/contractors/notes/${noteId}`,
+    updateByNoteId: noteId => `${backendUrl}/saas/contractors/notes/${noteId}`,
+};
+
+const createRecordNote = async (recordId, data, context) => {
+    return requests.postRequestHandler(Endpoints.create(recordId), data, context);
+};
+
+const getNotesByRecordId = async (recordId, context) => {
+    return requests.getRequestHandler(Endpoints.getNotesByRecordId(recordId), {}, context);
+};
+
+const getNotesCountByRecordId = async (recordId, context) => {
+    return requests.getRequestHandler(Endpoints.getNotesCountByRecordId(recordId), {}, context);
+};
+
+const deleteByNoteId = async (id, data, context) => {
+    const headers = {};
+    const params = {};
+    return requests.deleteRequestHandler(Endpoints.deleteByNoteId(id), context, headers, params, data);
+};
+
+const updateByNoteId = async (id, data, context) => {
+    return requests.putRequestHandler(Endpoints.updateByNoteId(id), data, context);
+};
+
+module.exports = {
+    createRecordNote,
+    getNotesByRecordId,
+    getNotesCountByRecordId,
+    deleteByNoteId,
+    updateByNoteId
+};

package/src/saas/internal-api/recordNotes/api/record.notes.setup.js

@@ -0,0 +1,29 @@
+const recordNotesAPI = require('./record.notes.api');
+
+const createRecordNote = async (recordId, data, context) => {
+    return recordNotesAPI.createRecordNote(recordId, data, context);
+};
+
+const getNotesByRecordId = async (recordId, context) => {
+    return recordNotesAPI.getNotesByRecordId(recordId, context);
+};
+
+const getNotesCountByRecordId = async (recordId, context) => {
+    return recordNotesAPI.getNotesCountByRecordId(recordId, context);
+};
+
+const deleteByNoteId = async (noteId, data, context) => {
+    return recordNotesAPI.deleteByNoteId(noteId, data, context);
+};
+
+const updateByNoteId = async (noteId, data, context) => {
+    return recordNotesAPI.updateByNoteId(noteId, data, context);
+};
+
+module.exports = {
+    createRecordNote,
+    getNotesByRecordId,
+    getNotesCountByRecordId,
+    deleteByNoteId,
+    updateByNoteId
+};

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

@@ -2,26 +2,26 @@ const requests = require('../../common/requests');
 const { backendUrl } = require('../../../../env').getEnv();
 
 const Endpoints = {
-    getTabsByProjectId: `${backendUrl}/saas/vendortab`,
-    create: `${backendUrl}/saas/vendortab`,
-    update: `${backendUrl}/saas/vendortab`,
-    delete: `${backendUrl}/saas/vendortab`
+	getTabsByProjectId: `${backendUrl}/saas/vendortab`,
+	create: `${backendUrl}/saas/vendortab`,
+	update: `${backendUrl}/saas/vendortab`,
+	delete: `${backendUrl}/saas/vendortab`
 };
 
 const getTabsByProjectId = async (projectId, context) => {
-    return requests.getRequestHandler(Endpoints.getTabsByProjectId, { projectId }, context).then(res => res.data);
+	return requests.getRequestHandler(Endpoints.getTabsByProjectId, { projectId }, context).then(res => res.data);
 };
 
 const createTab = async (tabModel, context) => {
-    return requests.postRequestHandler(Endpoints.create, tabModel, context);
+	return requests.postRequestHandler(Endpoints.create, tabModel, context);
 };
 
 const updateTab = async (tabModel, context) => {
-    return requests.postRequestHandler(Endpoints.update, tabModel, context);
+	return requests.postRequestHandler(Endpoints.update, tabModel, context);
 };
 
 const deleteTab = async (tabId, context) => {
-    return requests.deleteRequestHandler(Endpoints.delete, context, {}, { tabId });
+	return requests.deleteRequestHandler(Endpoints.delete, context, {}, { tabId });
 };
 
-module.exports = { getTabsByProjectId, createTab, updateTab, deleteTab };
+module.exports = { getTabsByProjectId, createTab, updateTab, deleteTab };

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

@@ -1,47 +1,47 @@
 const tabsAPI = require('./tabs.api');
 
 const createTab = async (projectId, tabName, tabType, context) => {
-    const tabModel = { projectId, tabName, type: tabType };
-    return tabsAPI.createTab(tabModel, context);
+	const tabModel = { projectId, tabName, type: tabType };
+	return tabsAPI.createTab(tabModel, context);
 };
 
 const updateTab = async (projectId, tabName, tabType, tabId, context) => {
-    const tabModel = { projectId, tabName, type: tabType, tabId };
-    return tabsAPI.updateTab(tabModel, context);
+	const tabModel = { projectId, tabName, type: tabType, tabId };
+	return tabsAPI.updateTab(tabModel, context);
 };
 
 const getTabsByProjectId = async (projectId, context) => {
-    return tabsAPI.getTabsByProjectId(projectId, context);
+	return tabsAPI.getTabsByProjectId(projectId, context);
 };
 
 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):
-        tabs.find(tab => tab.tabName === tabName);
-    return requestedTab;
+	const tabs = await tabsAPI.getTabsByProjectId(projectId, context);
+	const requestedTab = tabType ?
+		tabs.find(tab => tab.tabName === tabName && tab.type === tabType) :
+		tabs.find(tab => tab.tabName === tabName);
+	return requestedTab;
 };
 
 const deleteTabById = async (tabId, context) => {
-    return tabsAPI.deleteTab(tabId, context);
+	return tabsAPI.deleteTab(tabId, context);
 };
 
 const getOrCreateTab = async (projectId, tabName, tabType, context) => {
-    const tabs = await getTabsByProjectId(projectId, context);
-    const existingTab = tabs.find(tab => tab.tabName === tabName && tab.type === tabType);
+	const tabs = await getTabsByProjectId(projectId, context);
+	const existingTab = tabs.find(tab => tab.tabName === tabName && tab.type === tabType);
 
-    if (existingTab) {
-        return existingTab;
-    }
+	if (existingTab) {
+		return existingTab;
+	}
 
-    return createTab(projectId, tabName, tabType, context);
+	return createTab(projectId, tabName, tabType, context);
 };
 
 module.exports = {
-    getTabsByProjectId,
-    createTab,
-    updateTab,
-    deleteTabById,
-    getOrCreateTab,
-    getTabsByName
-};
+	getTabsByProjectId,
+	createTab,
+	updateTab,
+	deleteTabById,
+	getOrCreateTab,
+	getTabsByName
+};

package/src/saas/internal-api/users/api/invite.api.js

@@ -2,28 +2,28 @@ const requests = require('../../common/requests');
 const { backendUrl } = require('../../../../env').getEnv();
 
 const Endpoints = {
-    invite: projectId => `${backendUrl}/saas/project/${projectId}/team-member`,
-    getByProjectId: projectId => `${backendUrl}/saas/project/${projectId}/team-members`,
-    getByEmail: email => `${backendUrl}/saas/team-member/by-email/${email}`,
-    delete: userId => `${backendUrl}/saas/users/${userId}`,
+	invite: projectId => `${backendUrl}/saas/project/${projectId}/team-member`,
+	getByProjectId: projectId => `${backendUrl}/saas/project/${projectId}/team-members`,
+	getByEmail: email => `${backendUrl}/saas/team-member/by-email/${email}`,
+	delete: userId => `${backendUrl}/saas/users/${userId}`
 };
 
 const invite = async (projectId, invitedUser, context) => {
-    return requests.putRequestHandler(Endpoints.invite(projectId), invitedUser, context).then(
-        res => res.data
-    );
+	return requests.putRequestHandler(Endpoints.invite(projectId), invitedUser, context).then(
+		res => res.data
+	);
 };
 
 const getUsersByProjectId = async (projectId, context) => {
-    return requests.getRequestHandler(Endpoints.getByProjectId(projectId), null, context).then(res => res.data);
+	return requests.getRequestHandler(Endpoints.getByProjectId(projectId), null, context).then(res => res.data);
 };
 
 const getUserByEmail = async (email, context) => {
-    return requests.getRequestHandler(Endpoints.getByEmail(email), null, context).then(res => res.data);
+	return requests.getRequestHandler(Endpoints.getByEmail(email), null, context).then(res => res.data);
 };
 
 const deleteUser = async (userId, context) => {
-    return requests.deleteRequestHandler(Endpoints.delete(userId), context);
+	return requests.deleteRequestHandler(Endpoints.delete(userId), context);
 };
 
-module.exports = { invite, getUsersByProjectId, getUserByEmail, deleteUser };
+module.exports = { invite, getUsersByProjectId, getUserByEmail, deleteUser };

package/src/saas/internal-api/users/api/invite.setup.js

@@ -1,19 +1,19 @@
 const inviteUserAPI = require('./invite.api');
 
 const invite = async (projectId, invitedUser, context) => {
-    return inviteUserAPI.invite(projectId, invitedUser, context);
+	return inviteUserAPI.invite(projectId, invitedUser, context);
 };
 
 const getUsersByProjectId = async (projectId, context) => {
-    return inviteUserAPI.getUsersByProjectId(projectId, context);
+	return inviteUserAPI.getUsersByProjectId(projectId, context);
 };
 
 const getUserByEmail = async (email, context) => {
-    return inviteUserAPI.getUserByEmail(email, context);
+	return inviteUserAPI.getUserByEmail(email, context);
 };
 
 const deleteUser = (userId, context) => {
-    return inviteUserAPI.deleteUser(userId, context);
+	return inviteUserAPI.deleteUser(userId, context);
 };
 
-module.exports = { invite, getUsersByProjectId, getUserByEmail, deleteUser };
+module.exports = { invite, getUsersByProjectId, getUserByEmail, deleteUser };

package/src/saas/internal-api/vendorProfile/api/vendor.profile.api.js

@@ -0,0 +1,14 @@
+const requests = require('../../common/requests');
+const { backendUrl } = require('../../../../env').getEnv();
+
+const Endpoints = {
+	getVendorProfileJson: (contractorId, requirementId) => `${backendUrl}/saas/vendorProfile/contractor/${contractorId}/requirement/${requirementId}/immediateComplianceReport`
+};
+
+const createVendorProfileReport = async (contractorId, requirementId, context) => {
+	return requests.getRequestHandler(Endpoints.getVendorProfileJson(contractorId, requirementId), {}, context);
+};
+
+module.exports = {
+	createVendorProfileReport
+};

package/src/saas/internal-api/vendorProfile/api/vendor.profile.setup.js

@@ -0,0 +1,8 @@
+const vendorProfileApi = require('./vendor.profile.api');
+
+const createVendorProfileReport = async (contractorId, requirementId, context) => {
+	return vendorProfileApi.createVendorProfileReport(contractorId, requirementId, context);
+};
+module.exports = {
+	createVendorProfileReport
+};

package/tests/env.test.js

@@ -5,37 +5,36 @@ const { expect } = chai;
 const env = require('../src/env');
 
 describe('Env | Test Core Logic', async function() {
-    it('Missing Configuration', async function() {
-        const expectedValidationError = 'Missing required configuration on your environment variables. The missing env-vars are "backendUrl,openapiUrl,environment".';
-
-        const badInput = {
-            credentials: { superUser: 'TestSuperUser', superUserPassword: 'TestSuperUserPassword' }
-        };
-
-        expect(() => env.init(badInput)).to.throw(expectedValidationError);
-    });
-
-    it('Assign Configuration', async function() {
-        const expectedSanityAssignVariables = {
-            'backendUrl': 'Test',
-            'openapiUrl': 'openapi',
-            'credentials': {
-                'superUser': 'TestSuperUser',
-                'superUserPassword': 'TestSuperUserPassword'
-            },
-            'environment': 'dev',
-            'accountCreationSecret': null
-        };
-
-        env.init({
-            backendUrl: 'Test',
-            openapiUrl: 'openapi',
-            environment: 'dev',
-            credentials: { superUser: 'TestSuperUser', superUserPassword: 'TestSuperUserPassword' }
-        });
-
-        const envVariables = env.getEnv();
-        expect(envVariables).to.deep.equal(expectedSanityAssignVariables, 'Assign configuration did not work properly');
-    });
-
+	it('Missing Configuration', async function() {
+		const expectedValidationError = 'Missing required configuration on your environment variables. The missing env-vars are "backendUrl,openapiUrl,environment".';
+
+		const badInput = {
+			credentials: { superUser: 'TestSuperUser', superUserPassword: 'TestSuperUserPassword' }
+		};
+
+		expect(() => env.init(badInput)).to.throw(expectedValidationError);
+	});
+
+	it('Assign Configuration', async function() {
+		const expectedSanityAssignVariables = {
+			'backendUrl': 'Test',
+			'openapiUrl': 'openapi',
+			'credentials': {
+				'superUser': 'TestSuperUser',
+				'superUserPassword': 'TestSuperUserPassword'
+			},
+			'environment': 'dev',
+			'accountCreationSecret': null
+		};
+
+		env.init({
+			backendUrl: 'Test',
+			openapiUrl: 'openapi',
+			environment: 'dev',
+			credentials: { superUser: 'TestSuperUser', superUserPassword: 'TestSuperUserPassword' }
+		});
+
+		const envVariables = env.getEnv();
+		expect(envVariables).to.deep.equal(expectedSanityAssignVariables, 'Assign configuration did not work properly');
+	});
 });