@getjones/test-infra 2.6.8 → 2.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getjones/test-infra",
-  "version": "2.6.8",
+  "version": "2.7.1",
   "description": "Providing internal and openapi interface",
   "main": "src/index.js",
   "scripts": {

package/src/common/commonFlows/records/records.js

@@ -16,6 +16,7 @@ const makeRecordNotResponsive = async function(recordId, context, { isTenant } =
 };
 
 const updateInviteDate = async function(recordId, inviteDate, context) {
+	await timeUtils.waitFor(1).seconds;
 	const updateResponse = await contractors.services.updateInviteDate(recordId, inviteDate, context);
 
 	if (updateResponse.status !== httpResponseStatusCodes.NO_CONTENT) {

package/src/common/consts/dashboardCharts.js

@@ -0,0 +1,17 @@
+const chartTypes = {
+	requiringAttention: 'requiringAttention',
+	expirationDatePerMonth: 'expirationDatePerMonth',
+	waivedByRequirement: 'waivedByRequirement'
+};
+const sortBy = {
+	companyName: 'SORT_BY_COMPANYNAME',
+	projectName: 'SORT_BY_PROJECT_NAME',
+	insuranceStatus: 'SORT_BY_INSURANCE_STATUS',
+	minPolicyExpiration: 'SORT_BY_MIN_POLICY_EXP'
+
+};
+
+module.exports = {
+	chartTypes,
+	sortBy
+};

package/src/common/utils/complianceUtil.js

@@ -0,0 +1,56 @@
+const { getEnv, getSystemUserIdentity } = require('../../env');
+const { credentials } = getEnv();
+
+const auditApi = require('../../saas/internal-api/compliance/api/audit/audit.api');
+
+const isReaudit = (contractorId, context) => {
+	return auditApi.isReaudit(contractorId, context);
+};
+
+const getAuditorId = () => {
+	const auditorIdentity = getSystemUserIdentity(credentials.auditorUser);
+	return auditorIdentity.id;
+};
+
+const getAuditMetadata = async (
+	auditorContext,
+	accountId,
+	projectId,
+	requirementId,
+	recordId,
+	{
+		isProjectOnboarding = false,
+		shouldSendNotificationToPM = false
+	} = {}) => {
+	const metadata = {
+		accountId,
+		projectId,
+		requirementId,
+		contractorId: recordId,
+		isProjectOnboarding,
+		shouldSendNotificationToPM
+	};
+
+	const isReauditResponse = await isReaudit(recordId, auditorContext);
+	metadata.isReaudit = isReauditResponse.data.isReaudit;
+
+	const recordDetailsResponse = await auditApi.getContractorDetailsForAudit(recordId, auditorContext);
+	const { vendorDetails } = recordDetailsResponse.data;
+
+	metadata.certificateId = vendorDetails.certificateDetails.certificateuploadId;
+	metadata.auditDates = {
+		contractorId: recordId,
+		contractorDateModified: vendorDetails.dateModified,
+		dateStartedAudit: recordDetailsResponse.dateStartedAudit,
+		contractorOverrideDateModified: vendorDetails.contractorOverrideDateModified,
+		contractCreateDate: vendorDetails.contractCreateDate
+	};
+
+	metadata.auditorId = await getAuditorId();
+
+	return metadata;
+};
+
+module.exports = {
+	getAuditMetadata
+};

package/src/common/utils/timeUtils.js

@@ -13,7 +13,8 @@ const formats = {
 	threadScheduler: '', // Passing empty string resolves moment.js format to ISO8601 standard like 2020-04-12T09:49:59Z;
 	monthDayYear12hTime: 'MMM D, YYYY h:mm A',
 	amPmTime: 'h:mm A',
-	yearMonthDay: 'YYYY-MM-DD'
+	yearMonthDay: 'YYYY-MM-DD',
+	shortedMonthName: 'MMM'
 };
 
 const peroids = {

package/src/defaults/configs/coverage.js

@@ -0,0 +1,227 @@
+const policies = require('../configs/polices');
+
+const defaultExpiryDate = '2030-10-10T00:00:00.000Z';
+const defaultEffectiveDate = '2020-10-10T00:00:00.000Z';
+
+const policiesConfig = {
+	[policies.policyNames.generalLiability]: {
+		key: 'generalLiability',
+		policyEntities: [
+			{
+				effectiveDate: defaultEffectiveDate,
+				expiryDate: defaultExpiryDate,
+				policyNumber: 'GL-12345'
+			}
+		],
+		limits: [
+			{
+				key: 'eachOccurrence',
+				value: 1000000
+			},
+			{
+				key: 'productsCompletedOperationsAggregate',
+				value: 3000000
+			},
+			{
+				key: 'personalAdvertisingInjury',
+				value: 1000000
+			},
+			{
+				key: 'medicalExpenses',
+				value: 5000
+			},
+			{
+				key: 'damageToRentedPremises',
+				value: 50000
+			},
+			{
+				key: 'generalAggregate',
+				value: 2000000
+			}
+		],
+		provisions: [
+			{
+				key: 'primaryNonContributoryProvision',
+				value: true
+			},
+			{
+				key: 'primaryNonContributoryForAdditionalInsured',
+				value: true
+			},
+			{
+				key: '10DaysNoticeOfCancellation',
+				value: true
+			},
+			{
+				key: 'contractualLiability',
+				value: true
+			},
+			{
+				key: 'perOccur',
+				value: true
+			},
+			{
+				key: 'perPolicy',
+				value: true
+			},
+			{
+				key: 'perProject',
+				value: true
+			}
+		]
+	},
+	[policies.policyNames.automobileLiability]: {
+		key: 'automobileLiability',
+		policyEntities: [
+			{
+				effectiveDate: defaultEffectiveDate,
+				expiryDate: defaultExpiryDate,
+				policyNumber: 'AL-12345'
+			}
+		],
+		limits: [
+			{
+				key: 'combinedSingleLimit',
+				value: 1000000
+			}
+		],
+		provisions: [
+			{
+				key: 'anyAuto',
+				value: true
+			},
+			{
+				key: 'waiverOfSubrogation',
+				value: true
+			},
+			{
+				key: 'hired',
+				value: true
+			}
+		]
+	},
+	[policies.policyNames.excessLiability]: {
+		key: 'excessLiability',
+		policyEntities: [
+			{
+				effectiveDate: defaultEffectiveDate,
+				expiryDate: defaultExpiryDate,
+				policyNumber: 'EL-12345'
+			}
+		],
+		limits: [
+			{
+				key: 'eachOccurrence',
+				value: 1000000
+			}
+		],
+		provisions: [
+			{
+				key: 'occur',
+				value: true
+			}
+		]
+	},
+	[policies.policyNames.umbrella]: {
+		key: 'umbrellaLiability',
+		policyEntities: [
+			{
+				effectiveDate: defaultEffectiveDate,
+				expiryDate: defaultExpiryDate,
+				policyNumber: 'Um-12345'
+			}
+		],
+		limits: [
+			{
+				key: 'eachOccurrence',
+				value: 5000000
+			},
+			{
+				key: 'aggregate',
+				value: 5000000
+			}
+		],
+		provisions: [
+			{
+				key: 'occur',
+				value: true
+			}
+		]
+	},
+	[policies.policyNames.workersCompensation]: {
+		key: 'workersCompensation',
+		policyEntities: [
+			{
+				effectiveDate: defaultEffectiveDate,
+				expiryDate: defaultExpiryDate,
+				policyNumber: 'WC-12345'
+			}
+		],
+		limits: [
+			{
+				key: 'employersLiabilityEachAccident',
+				value: 1000000
+			},
+			{
+				key: 'employersLiabilityDiseaseEachEmployee',
+				value: 1000000
+			}
+		],
+		provisions: [
+			{
+				key: 'statutoryLimitsRequired',
+				value: true
+			}
+		]
+	},
+	[policies.policyNames.fidelityCrime]: {
+		key: 'fidelityCrime',
+		policyEntities: [
+			{
+				effectiveDate: defaultEffectiveDate,
+				expiryDate: defaultExpiryDate,
+				policyNumber: 'FC-12345'
+			}
+		],
+		limits: [
+			{
+				key: 'clientProperty',
+				value: 1000000
+			}
+		],
+		provisions: [
+		]
+	},
+	[policies.policyNames.cyberLiability]: {
+		key: 'cyberLiability',
+		policyEntities: [
+			{
+				effectiveDate: defaultEffectiveDate,
+				expiryDate: defaultExpiryDate,
+				policyNumber: 'CL-12345'
+			}
+		],
+		limits: [
+			{
+				key: 'eachClaim',
+				value: 1000000
+			}
+		],
+		provisions: [
+		]
+	}
+};
+
+const getAllAvailablePolicies = () => Object.keys(policiesConfig);
+
+const getRequiredPoliciesMinimumForAutocomplete = () => {
+	const policies = getAllAvailablePolicies();
+	policies.length = 2;
+	return policies;
+};
+
+module.exports = {
+	getAllAvailablePolicies,
+	getRequiredPoliciesMinimumForAutocomplete,
+	policiesConfig
+};

package/src/defaults/configs/polices.js

@@ -39,7 +39,8 @@ const attributeNames = {
 	cancellationTerms: 'Cancellation Terms',
 	coiAuthentication: 'COI authentication',
 	signature: 'Signature',
-	occur: 'Occur'
+	occur: 'Occur',
+	text: 'text'
 };
 
 module.exports = {

package/src/defaults/index.js

@@ -1,5 +1,6 @@
 const audit = require('./configs/auditConfigs');
 const polices = require('./configs/polices');
 const requirement = require('./configs/requirement');
+const coverage = require('./configs/coverage');
 
-module.exports = { audit, polices, requirement };
+module.exports = { audit, polices, requirement, coverage };

package/src/factory/index.js

@@ -1,5 +1,7 @@
 const records = require('./records/records');
+const users = require('./users/users');
 
 module.exports = {
-	records
+	records,
+	users
 };

package/src/factory/records/records.js

@@ -87,7 +87,7 @@ const prepareRecord = async (recordCompany, recordEmail, status, tabId, requirem
 	} while (auditResponse.status !== httpResponseStatusCodes.NO_CONTENT && retries--);
 
 	if (auditResponse.status !== httpResponseStatusCodes.NO_CONTENT) {
-		throw Error(`Failed to audit record ${record.company}\n${auditResponse}`);
+		throw Error(`Failed to audit record ${recordCompany}\n${auditResponse}`);
 	}
 
 	return recordId;
@@ -112,7 +112,7 @@ const prepareAboutToExpiredRecord = (recordCompany, recordEmail, tabId, requirem
 const prepareWaivedRecord = async (recordCompany, recordEmail, tabId, requirementId, context) => {
 	const recordId = await prepareRecord(recordCompany, recordEmail, complianceStatuses.notCompliant, tabId, requirementId, context);
 
-	const record = await contractors.services.getContractorById(recordId, context);
+	const { data: record } = await contractors.services.getContractorById(recordId, context);
 	await compliance.services.waive.waiveAll(record, context);
 
 	return recordId;

package/src/factory/users/users.js

@@ -0,0 +1,79 @@
+const { getEnv } = require('../../env');
+const httpResponseStatusCodes = require('../../common/httpResponseStatusCodes.json');
+
+const { credentials } = getEnv();
+
+const users = require('../../saas/internal-api/users');
+const { InviteUserModel } = users.models;
+
+const defaultsPassword = credentials.strongPassword;
+const roles = {
+	readOnly: 'Read-only',
+	inviter: 'Inviter',
+	cm: 'Compliance Manager'
+};
+
+const generateFullName = role => `${role} User`;
+
+const inviteSaasUser = async (username, role, projectIds, context) => {
+	const userResponse = await users.services.getUserByEmail(username, context);
+
+	if (userResponse.data && userResponse.data.subuserId) {
+		return;
+	}
+
+	const inviteUserModel = new InviteUserModel(username, role, projectIds, context);
+	const inviteResponse = await users.services.inviteUser([inviteUserModel], context);
+
+	if (inviteResponse.status !== httpResponseStatusCodes.NO_CONTENT) {
+		throw new Error(`Failed to invite user with email: ${username}\n${inviteResponse}`);
+	}
+};
+
+const signupSaasUser = async (username, role, context) => {
+	const userResponse = await users.services.getUserByEmail(username, context);
+
+	//Already signup user
+	if (userResponse.data.isVerified) {
+		return;
+	}
+
+	const signupUserModel = await users.util.getSignupUserModel(username, role, generateFullName(role), defaultsPassword, context);
+	const signupResponse = await users.services.signupUser(signupUserModel, context);
+
+	if (signupResponse.status !== httpResponseStatusCodes.OK) {
+		throw new Error(`Failed to invite ${role} user with email: ${username}\n${signupResponse}`);
+	}
+};
+
+const prepareUser = async (username, role, projectIds, context, { signup = true } = {}) => {
+	await inviteSaasUser(username, role, projectIds, context);
+
+	signup && await signupSaasUser(username, role, context);
+
+	const userResponse = await users.services.getUserByEmail(username, context);
+
+	if (userResponse.status !== httpResponseStatusCodes.OK) {
+		throw new Error(`Failed to prepare ${role} user with email: ${username}\n${userResponse}`);
+	}
+
+	return userResponse.data;
+};
+
+const prepareComplianceManagerUser = (username, projectIds, context, { signup } = {}) => {
+	return prepareUser(username, roles.cm, projectIds, context, { signup });
+};
+
+const prepareInviterUser = (username, projectIds, context, { signup } = {}) => {
+	return prepareUser(username, roles.inviter, projectIds, context, { signup });
+};
+
+const prepareReadOnlyUser = (username, projectIds, context, { signup } = {}) => {
+	return prepareUser(username, roles.readOnly, projectIds, context, { signup });
+};
+
+module.exports = {
+	prepareComplianceManagerUser,
+	prepareInviterUser,
+	prepareReadOnlyUser
+};

package/src/index.js

@@ -22,6 +22,8 @@ const getInternalAPI = () => {
 
 	const coi = require('./saas/internal-api/coi');
 	const compliance = require('./saas/internal-api/compliance');
+	const auditNotes = require('./saas/internal-api/auditNotes');
+
 	const users = require('./saas/internal-api/users');
 
 	const reports = require('./saas/internal-api/reports');
@@ -48,6 +50,7 @@ const getInternalAPI = () => {
 		requests,
 		coi,
 		compliance,
+		auditNotes,
 		reports,
 		users,
 		charts,

package/src/saas/internal-api/auditNotes/api/audit.notes.api.js

@@ -0,0 +1,40 @@
+const requests = require('../../../../common/requests/cookieAuth/requests');
+const { backendUrl } = require('../../../../env').getEnv();
+
+const saas_notes_path = 'saas/notes';
+const Endpoints = {
+	saasNotes: `${backendUrl}/${saas_notes_path}`,
+	getNotesForAuditor: `${backendUrl}/${saas_notes_path}/auditor`,
+	updateNote: `${backendUrl}/${saas_notes_path}/update`,
+	deleteNote: noteId => `${backendUrl}/${saas_notes_path}/${noteId}`
+};
+
+const createAuditNote = (noteModel, context) => {
+	return requests.postRequestHandler(Endpoints.saasNotes, noteModel, context);
+};
+
+const getAuditNotesByProjectId = (projectId, context) => {
+	const params = { projectId };
+	return requests.getRequestHandler(Endpoints.saasNotes, params, context);
+};
+
+const getAuditNotesByRecordId = (recordId, context) => {
+	const params = { contractorId: recordId };
+	return requests.getRequestHandler(Endpoints.getNotesForAuditor, params, context);
+};
+
+const updateAuditNote = (noteModel, context) => {
+	return requests.postRequestHandler(Endpoints.updateNote, noteModel, context);
+};
+
+const deleteAuditNoteById = (noteId, context) => {
+	return requests.deleteRequestHandler(Endpoints.deleteNote(noteId), context);
+};
+
+module.exports = {
+	createAuditNote,
+	getAuditNotesByProjectId,
+	getAuditNotesByRecordId,
+	updateAuditNote,
+	deleteAuditNoteById
+};

package/src/saas/internal-api/auditNotes/api/audit.notes.service.js

@@ -0,0 +1,115 @@
+const auditApi = require('./audit.notes.api');
+const { AuditNoteModel } = require('../models/audit.note.model');
+const { validateType } = require('../../../../common/validations/typeValidations');
+const httpResponseStatusCodes = require('../../../../common/httpResponseStatusCodes.json');
+
+const createAuditNote = async (auditNoteModel, context) => {
+	validateType(auditNoteModel, AuditNoteModel);
+	const response = await auditApi.createAuditNote(auditNoteModel, context);
+
+	if (response.status !== httpResponseStatusCodes.NO_CONTENT) {
+		throw Error(`Failed to create audit note - Response: ${response.status}`);
+	}
+
+	return response;
+};
+
+const getAuditNotesByProjectId = async (projectId, context) => {
+	const response = await auditApi.getAuditNotesByProjectId(projectId, context);
+
+	if (response.status !== httpResponseStatusCodes.OK) {
+		throw Error(`Failed to get audit notes by project id: ${projectId} - Response: ${response.status}`);
+	}
+
+	return response.data;
+};
+
+const getAuditNotesByRecordId = async (recordId, context) => {
+	const response = await auditApi.getAuditNotesByRecordId(recordId, context);
+
+	if (response.status !== httpResponseStatusCodes.OK) {
+		throw Error(`Failed to get audit notes by record id: ${recordId} - Response: ${response.status}`);
+	}
+
+	return response.data;
+};
+
+const updateAuditNote = async (auditNoteModel, context) => {
+	validateType(auditNoteModel, AuditNoteModel);
+	const response = await auditApi.updateAuditNote(auditNoteModel, context);
+
+	if (response.status !== httpResponseStatusCodes.NO_CONTENT) {
+		throw Error(`Failed to update audit note - Response: ${response.status}`);
+	}
+
+	return response;
+};
+
+const deleteAuditNoteById = (noteId, context) => {
+	return auditApi.deleteAuditNoteById(noteId, context);
+};
+
+const deleteAllAuditNotesInProject = async (projectId, context) => {
+	const existingAuditNotes = await getAuditNotesByProjectId(projectId, context);
+
+	for (const auditNotesType in existingAuditNotes) {
+		if (existingAuditNotes[auditNotesType] && existingAuditNotes[auditNotesType].length) {
+			await deleteAuditNotesByIds(existingAuditNotes[auditNotesType], context);
+		}
+	}
+};
+
+const deleteAllAccountLevelNotes = async (projectId, context) => { //does not delete all notes in account, only account level notes!
+	const existingAuditNotes = await getAuditNotesByProjectId(projectId, context);
+	const accountLevelNotesArr = existingAuditNotes.Account;
+
+	if (accountLevelNotesArr.length) {
+		await deleteAuditNotesByIds(accountLevelNotesArr, context);
+	}
+};
+
+const deleteAllProjectLevelNotes = async (projectId, context) => { //does not delete all notes in project, only project level notes!
+	const existingAuditNotes = await getAuditNotesByProjectId(projectId, context);
+	const projectLevelNotesArr = existingAuditNotes.Project;
+
+	if (projectLevelNotesArr.length) {
+		await deleteAuditNotesByIds(projectLevelNotesArr, context);
+	}
+};
+
+const deleteAllRequirementLevelNotes = async (projectId, context) => {
+	const existingAuditNotes = await getAuditNotesByProjectId(projectId, context);
+	const requirementLevelNotesArr = existingAuditNotes.Requirement;
+
+	if (requirementLevelNotesArr.length) {
+		await deleteAuditNotesByIds(requirementLevelNotesArr, context);
+	}
+};
+
+module.exports = {
+	createAuditNote,
+	getAuditNotesByProjectId,
+	getAuditNotesByRecordId,
+	updateAuditNote,
+	deleteAuditNoteById,
+	deleteAllAccountLevelNotes,
+	deleteAllProjectLevelNotes,
+	deleteAllRequirementLevelNotes,
+	deleteAllAuditNotesInProject
+};
+
+async function deleteAuditNotesByIds(notes, context) {
+	const failed = [];
+	for (const note of notes) {
+		const deleteNoteResponse = await deleteAuditNoteById(note.id, context);
+
+		if (deleteNoteResponse.status !== httpResponseStatusCodes.NO_CONTENT) { //see what EP of delete is returning when all goes well - maybe need to change !status
+			console.error('Failed to delete note: ', note.id);
+			failed.push(deleteNoteResponse);
+		}
+	}
+
+	if (failed.length) {
+		throw Error(`Failed to delete ${failed.length} of ${existingAuditNotes.length} records in account. Failed with status: ${ failed[0].status }`);
+	}
+}

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

@@ -0,0 +1,4 @@
+const services = require('./api/audit.notes.service');
+const models = require('./models/audit.note.model');
+
+module.exports = { services, models };

package/src/saas/internal-api/auditNotes/models/audit.note.model.js

@@ -0,0 +1,30 @@
+class AuditNoteModel {
+	constructor(noteEntityType, entityId, note, { id, gapQuote, requirementName } = {}) {
+		validateNoteEntityType(noteEntityType);
+
+		this.noteEntityType = noteEntityType;
+		this.entityId = entityId;
+		this.note = note;
+
+		this.id = id;
+		this.gapQuote = gapQuote;
+		this.requirementName = requirementName;
+	}
+}
+
+const auditNoteTypes = {
+	account: 'Account',
+	project: 'Project',
+	requirement: 'Requirement'
+};
+
+module.exports = {
+	AuditNoteModel,
+	auditNoteTypes
+};
+
+const validateNoteEntityType = noteEntityType => {
+	if (![auditNoteTypes.account, auditNoteTypes.project, auditNoteTypes.requirement].includes(noteEntityType)) {
+		throw new Error(`Invalid noteEntityType: ${noteEntityType}`);
+	}
+};

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

@@ -7,7 +7,8 @@ const Endpoints = {
 	audit: `${backendUrl}/saas/auditor/contractors/submit/audits`,
 	contractorDetailsForAudit: contractorId => `${backendUrl}/saas/auditor/contractors/${contractorId}/master-audit`,
 	requirementDetailsForAudit: contractorId => `${backendUrl}/saas/auditor/contractor/${contractorId}/requirement`,
-	isReaudit: contractorId => `${backendUrl}/saas/auditor/contractors/${contractorId}/isreaudit`
+	isReaudit: contractorId => `${backendUrl}/saas/auditor/contractors/${contractorId}/isreaudit`,
+	revertCoi: contractorId => `${backendUrl}/saas/auditor/contractors/${contractorId}/coi/revert`
 };
 
 const audit = async (contractorId, auditRequestModel, context) => {
@@ -15,6 +16,10 @@ const audit = async (contractorId, auditRequestModel, context) => {
 	return requests.postRequestHandler(Endpoints.audit, auditRequestModel, context);
 };
 
+const revertCoi = (contractorId, dateModified, context) => {
+	return requests.postRequestHandler(Endpoints.revertCoi(contractorId), dateModified, context);
+};
+
 const isReaudit = (contractorId, context) => {
 	return requests.getRequestHandler(Endpoints.isReaudit(contractorId), {}, context);
 };
@@ -33,6 +38,7 @@ const getRequirementDetailsForAudit = (contractorId, context) => {
 
 module.exports = {
 	audit,
+	revertCoi,
 	isReaudit,
 	getAuditorContractorList,
 	getContractorDetailsForAudit,