@getjones/test-infra 1.1.1 → 1.1.3

package/README.md

@@ -41,6 +41,7 @@ module.exports = {
     * accounts
     * accountSettings
     * projects
+    * projectSettings
 
 ```node
 const { auth, accounts, accountSettings, projects } = internalAPI;
@@ -261,4 +262,52 @@ const createProjectInput = {
 
 const createProject = async (project, accountName, context) => {
 };
-```
+```
+
+### projectSettings
+
+```node
+
+/**
+ *
+ * @param accountName (string)
+ * @param context (string): Should contain cookie
+ */
+ 
+const getProjectsByAccountName = async (accountName, context) => {
+};
+
+/**
+ *
+ * @param settings (object)
+ * @param context (string): Should contain cookie
+ */
+
+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:  {
+    marketplaceEnabled: false,
+    marketplacePreApproved: false,
+    marketplacePublicLink: false
+},
+    ocrEnabled: false,
+    onboardingPhase: false,
+    projectId: null,
+    qrEnabled: false,
+    tenantSolution: false
+};
+
+```
+
+
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getjones/test-infra",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Providing internal and openapi interface",
   "main": "src/index.js",
   "scripts": {
@@ -10,6 +10,7 @@
   "license": "ISC",
   "dependencies": {
     "axios": "^0.21.1",
+    "axios-file": "^1.0.17",
     "chai": "^4.3.4",
     "dotenv": "^8.2.0",
     "enum": "^3.0.4",

package/src/env.js

@@ -4,6 +4,7 @@ let privateMembers = {
     credentials: null,
     environment: null,
     accountCreationSecret: null,
+    threadSchedulerSecret: null
 };
 
 const init = conf => {
@@ -28,8 +29,13 @@ const requiredValidation = object => {
     }
 };
 
+const isLocalhost = () => {
+    return privateMembers.backendUrl.includes('localhost');
+};
+
 module.exports = {
     init,
     getEnv: () => privateMembers,
-    requiredValidation
+    requiredValidation,
+    isLocalhost
 };

package/src/index.js

@@ -4,11 +4,12 @@ const init = conf => {
     env.init(conf);
     const internalAPI = getInternalAPI();
     const openAPI = getOpenAPI();
-    return { internalAPI, openAPI };
+    const threadScheduler = require('./saas/thread-scheduler/runner');
+
+    return { internalAPI, openAPI, threadScheduler };
 };
 
 const getInternalAPI = () => {
-
     const auth = require('./saas/internal-api/auth');
     const accounts = require('./saas/internal-api/accounts');
 
@@ -18,20 +19,34 @@ const getInternalAPI = () => {
     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
+        contractors,
+        coi,
+        compliance,
+        reports,
+        users,
     };
+
     return internalAPI;
 };
 
 const getOpenAPI = () => {
     const tabs = require('./saas/openapi/tabs/tabs.setup');
-    const openAPI = { tabs };
+    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 };
     return openAPI;
 
 };

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

@@ -21,8 +21,18 @@ const getIcsCookie = async () => {
     return await getAuthCookie(credentials.superUser, credentials.superUserPassword);
 };
 
+const getAuditorCookie = async () => {
+    const { auditorUser, auditorPassword } = credentials;
+    requiredValidation({
+        'credentials.auditorUser': auditorUser,
+        'credentials.auditorPassword': auditorPassword
+    });
+    return await getAuthCookie(auditorUser, auditorPassword);
+};
+
 module.exports = {
     getAuthCookie,
-    getIcsCookie
+    getIcsCookie,
+    getAuditorCookie
 };
 

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

@@ -0,0 +1,29 @@
+const axiosFile = require('axios-file');
+const requests = require('../../common/requests');
+
+const { backendUrl } = require('../../../../env').getEnv();
+
+const Endpoints = {
+    uploadToS3: `${backendUrl}/_saas/coi/upload`,
+    submitCoi: `${backendUrl}/coi/merge`,
+    getCoiPresignedUrl: fileName => `${backendUrl}/saas/coi/${fileName}`
+};
+
+const uploadToS3 = async (contractorId, fileData) => {
+    return axiosFile({
+        url: Endpoints.uploadToS3,
+        method: 'post',
+        params: { contractorId },
+        data: { fileData }
+    });
+};
+
+const submitCoi = async submitCoiModel => {
+    return requests.postRequestHandler(Endpoints.submitCoi, submitCoiModel).then(res => res.data);
+};
+
+const getCoiPreSignedUrl = async (coiFileName, context) => {
+    return requests.getRequestHandler(Endpoints.getCoiPresignedUrl(coiFileName), {}, context).then(res => res.data);
+};
+
+module.exports = { uploadToS3, submitCoi, getCoiPreSignedUrl };

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

@@ -0,0 +1,18 @@
+const coiApi = require('./coi.api');
+const { SubmitCoiModel } = require('../models/submit.coi.model');
+const { validateType } = require('../../../../common/validations/typeValidations');
+
+const uploadToS3 = async (contractorId, fileData) => {
+    return coiApi.uploadToS3(contractorId, fileData);
+};
+
+const submitCoi = async submitCoiModel => {
+    validateType(submitCoiModel, SubmitCoiModel);
+    return coiApi.submitCoi(submitCoiModel);
+};
+
+const getCoiPreSignedUrl = async (coiFileName, context) => {
+    return coiApi.getCoiPreSignedUrl(coiFileName, context);
+};
+
+module.exports = { uploadToS3, submitCoi, getCoiPreSignedUrl };

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

@@ -0,0 +1,6 @@
+const submitCoiModel = require('./models/submit.coi.model');
+const services = require('./api/coi.setup');
+
+const models = { submit: submitCoiModel };
+
+module.exports = { services, models };

package/src/saas/internal-api/coi/models/submit.coi.model.js

@@ -0,0 +1,9 @@
+function SubmitCoiModel(contractorId, fileIds, uploadedBy, uploaderEmail, isContractorExist = true) {
+    this.contractorId = contractorId;
+    this.chosenIds = fileIds;
+    this.uploadedBy = uploadedBy;
+    this.uploaderEmail = uploaderEmail;
+    this.isContractorExist = isContractorExist;
+}
+
+module.exports = { SubmitCoiModel };

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

@@ -0,0 +1,26 @@
+const requests = require('../../../common/requests');
+const { backendUrl } = require('../../../../../env').getEnv();
+
+const Endpoints = {
+    preAudit: contractorId => `${backendUrl}/saas/auditor/contractors/${contractorId}/master-audit`,
+    audit: contractorId => `${backendUrl}/saas/auditor/contractors/${contractorId}/audits`,
+    contractorDetailsForAudit: contractorId => `${backendUrl}/saas/auditor/contractors/${contractorId}/master-audit`,
+    requirementDetailsForAudit: contractorId => `${backendUrl}/saas/auditor/contractor/${contractorId}/requirement`
+};
+
+const audit = async (contractorId, auditRequestModel, context) => {
+    const response = await requests.getRequestHandler(Endpoints.preAudit(contractorId), {}, context);
+    return requests.postRequestHandler(Endpoints.audit(contractorId), auditRequestModel, context).then(res => res.data);
+};
+
+const getContractorDetailsForAudit = async (contractorId, context) => {
+    return requests.getRequestHandler(Endpoints.contractorDetailsForAudit(contractorId),
+        {}, context).then(res => res.data);
+};
+
+const getRequirementDetailsForAudit = async (contractorId, context) => {
+    return requests.getRequestHandler(Endpoints.requirementDetailsForAudit(contractorId),
+        {}, context).then(res => res.data);
+};
+
+module.exports = { audit, getContractorDetailsForAudit, getRequirementDetailsForAudit };

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

@@ -0,0 +1,18 @@
+const auditApi = require('./audit.api');
+const { AuditRequestModel } = require('../../models/audit/audit.model');
+const { validateType } = require('../../../../../common/validations/typeValidations');
+
+const audit = async (auditRequestModel, context) => {
+    validateType(auditRequestModel, AuditRequestModel);
+    return auditApi.audit(auditRequestModel.auditData.contractorId, auditRequestModel, context);
+};
+
+const getContractorDetailsForAudit = async (contractorId, context) => {
+    return auditApi.getContractorDetailsForAudit(contractorId, context);
+};
+
+const getRequirementDetailsForAudit = async (contractorId, context) => {
+    return auditApi.getRequirementDetailsForAudit(contractorId, context);
+};
+
+module.exports = { audit, getContractorDetailsForAudit, getRequirementDetailsForAudit };

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

@@ -0,0 +1,23 @@
+const requests = require('../../../common/requests');
+const { backendUrl } = require('../../../../../env').getEnv();
+
+const Endpoints = {
+    waive: contractorId => `${backendUrl}/saas/contractors/${contractorId}/waiver`,
+    retract: contractorId => `${backendUrl}/saas/contractors/${contractorId}/waiver`
+};
+
+const waive = async (contractorId, waiveRequestModel, context) => {
+    const status = waiveRequestModel.status;
+    delete waiveRequestModel.status;
+    return requests.postRequestHandler(Endpoints.waive(contractorId), waiveRequestModel,
+        context, {}, { status }).then(res => res.data);
+};
+
+const retract = async (contractorId, retractRequestModel, context) => {
+    const status = retractRequestModel.status;
+    delete retractRequestModel.status;
+    return requests.postRequestHandler(Endpoints.retract(contractorId), retractRequestModel,
+        context, {}, { status }).then(res => res.data);
+};
+
+module.exports = { waive, retract };

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

@@ -0,0 +1,15 @@
+const waiveApi = require('./waive.api');
+const { WaiveRequestModel, RetractRequestModel } = require('../../models/waive/waive.model');
+const { validateType } = require('../../../../../common/validations/typeValidations');
+
+const waive = async (waiveRequestModel, context) => {
+    validateType(waiveRequestModel, WaiveRequestModel);
+    return waiveApi.waive(waiveRequestModel.contractorId, waiveRequestModel, context);
+};
+
+const retract = async (retractRequestModel, context) => {
+    validateType(retractRequestModel, RetractRequestModel);
+    return waiveApi.retract(retractRequestModel.contractorId, retractRequestModel, context);
+};
+
+module.exports = { waive, retract };

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

@@ -0,0 +1,10 @@
+const auditModels = require('./models/audit/audit.model');
+const auditServices = require('./api/audit/audit.setup');
+
+const waiveModels = require('./models/waive/waive.model');
+const waiveServices = require('./api/waive/waive.setup');
+
+const models = { audit: auditModels, waive: waiveModels };
+const services = { audit: auditServices, waive: waiveServices };
+
+module.exports = { services, models };

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

@@ -0,0 +1,72 @@
+const COI_AUDIT_STATUSES = {
+    NOT_AUDITED: '0',
+    REAUDIT: '3'
+};
+
+const AUDIT_ENTITY_STATUSES = {
+    YES: 'Yes',
+    NO: 'No',
+    EMPTY: 'empty',
+    OTHER: 'other',
+    CLAIMS: 'Claims'
+};
+
+const AUDIT_ATTRIBUTE_NAMES = {
+    CERTIFICATE_ISSUE_DATE: 'certIssueDate'
+};
+
+const AUDIT_POLICY_NAMES = {
+    GENERAL_LIABILITY: ''
+};
+
+const AUDITOR_ROLE = 'Auditor';
+
+function AuditRequestModel({
+    accountId = null,
+    projectId = null,
+    requirementId = null,
+    contractorId = null,
+    certificateId = null,
+    auditorId = null,
+    auditEntities = null,
+    dateModified = null,
+    isReaudit = null,
+    isProjectOnboarding = false,
+    auditorRole = AUDITOR_ROLE,
+    shouldSendNotificationToPM = true
+}) {
+    const auditData = {
+        userId: accountId,
+        projectId: projectId,
+        requirementId: requirementId,
+        contractorId: contractorId,
+        certificateId: certificateId,
+        auditorId: auditorId,
+        policyDetails: auditEntities,
+        auditorStatus: COI_AUDIT_STATUSES.NOT_AUDITED,
+        dateModified: dateModified,
+        isReaudit: isReaudit,
+        projectOnboarding: isProjectOnboarding,
+        role: auditorRole,
+        sendNotificationToPM: shouldSendNotificationToPM
+    };
+
+    this.auditData = auditData;
+    this.dateModified = dateModified;
+}
+
+function AuditEntityModel(policyId, attributeName, status, value) {
+    this.contractorInsuranceId = policyId;
+    this.limitname = attributeName;
+    this.status = status;
+    this.value = value;
+}
+
+module.exports = {
+    AuditRequestModel,
+    AuditEntityModel,
+    COI_AUDIT_STATUSES,
+    AUDIT_ENTITY_STATUSES,
+    AUDIT_ATTRIBUTE_NAMES,
+    AUDIT_POLICY_NAMES
+};

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

@@ -0,0 +1,45 @@
+const DEFAULT_USER_ROLE = 'ICS';
+
+const WAIVE_ACTIONS = {
+    WAIVE: 'ignored',
+    RETRACT: 'notIgnored'
+};
+
+const WAIVER_REASONS = {
+    BUSINESS_DECISION: 'Business_Decision',
+    NO_EXPOSURE: 'No_Exposure',
+    EXECUTIVE_APPROVAL: 'Executive_Approval'
+};
+
+function WaiveRequestModel({
+    userId,
+    contractorId,
+    auditId,
+    waiverReason,
+    remarks = '',
+    userRole = DEFAULT_USER_ROLE
+}) {
+    this.auditorContractorId = auditId;
+    this.contractorId = contractorId;
+    this.userId = userId;
+    this.waiverReason = waiverReason;
+    this.remarks = remarks;
+
+    this.userRole = userRole;
+    this.status = WAIVE_ACTIONS.WAIVE;
+}
+
+function RetractRequestModel({ userId, contractorId, auditId, userRole = DEFAULT_USER_ROLE }) {
+    this.auditorContractorId = auditId;
+    this.contractorId = contractorId;
+    this.userId = userId;
+    this.userRole = userRole;
+    this.status = WAIVE_ACTIONS.RETRACT;
+}
+
+module.exports = {
+    WaiveRequestModel,
+    RetractRequestModel,
+    WAIVE_ACTIONS,
+    WAIVER_REASONS
+};

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

@@ -4,7 +4,12 @@ const { backendUrl } = require('../../../../env').getEnv();
 const Endpoints = {
     create: `${backendUrl}/saas/contractors/invite`,
     get: `${backendUrl}/saas/contractors`,
+    getContractorById: contractorId => `${backendUrl}/saas/contractor/${contractorId}`,
     delete: contractorId => `${backendUrl}/saas/contractor/${contractorId}`,
+    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`
 };
 
 const createContractors = async (createContractorModel, context) => {
@@ -15,8 +20,39 @@ const getContractorsByAccountId = async (params, context) => {
     return requests.getRequestHandler(Endpoints.get, params, context).then(res => res.data);
 };
 
+const getContractorById = async (contractorId, context) => {
+    return requests.getRequestHandler(Endpoints.getContractorById(contractorId), {}, context).then(res => res.data);
+};
+
 const deleteByContractorId = async (contractorId, context) => {
     return requests.deleteRequestHandler(Endpoints.delete(contractorId), context);
 };
 
-module.exports = { createContractors, getContractorsByAccountId, deleteByContractorId };
+const archiveByContractorId = async (contractorId, context) => {
+    return requests.deleteRequestHandler(Endpoints.archive(contractorId), context);
+};
+
+const restoreByContractorId = async (contractorId, context) => {
+    return requests.postRequestHandler(Endpoints.restore(contractorId), {}, context);
+};
+
+const editContractor = async (editContractorModel, context) => {
+    const params = { updateInfoUser: 'EditVendor' };
+    return requests.postRequestHandler(Endpoints.edit(editContractorModel.contractorId), editContractorModel, context, {}, params).then(res => res.data);
+};
+
+const updateExpiryDate = async (contractorId, expiryDate, policyName) => {
+    const data = { [policyName]: expiryDate };
+    return requests.postRequestHandler(Endpoints.updateVendorExpiryDate(contractorId), data);
+};
+
+module.exports = {
+    createContractors,
+    getContractorsByAccountId,
+    getContractorById,
+    deleteByContractorId,
+    archiveByContractorId,
+    restoreByContractorId,
+    editContractor,
+    updateExpiryDate
+};

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

@@ -1,18 +1,54 @@
 const contractorsAPI = require('./contractors.api');
 const { CreateContractorModel } = require('../models/create.contractor.model');
+const { ContractorModel } = require('../models/edit.contractor.model');
 const { validateType } = require('../../../../common/validations/typeValidations');
+const requests = require('../../common/requests');
 
 const createContractors = async (createContractorsModel, context) => {
     validateType(createContractorsModel, CreateContractorModel);
     return contractorsAPI.createContractors(createContractorsModel, context);
 };
 
-const getContractorsByAccountId = async (accountId, context) => {
-    return contractorsAPI.getContractorsByAccountId({ accountId }, context);
+const getContractorsByAccountId = async (accountId, context, activationStatus = null) => {
+    if (activationStatus) {
+        activationStatus = activationStatus.reduce((f, s) => `${f},${s}`);
+    }
+
+    return contractorsAPI.getContractorsByAccountId({ accountId, activationStatus }, context);
+};
+
+const getContractorById = (contractorId, context) => {
+    return contractorsAPI.getContractorById(contractorId, context);
 };
 
 const deleteByContractorId = (contractorId, context) => {
     return contractorsAPI.deleteByContractorId(contractorId, context);
 };
 
-module.exports = { createContractors, getContractorsByAccountId, deleteByContractorId };
+const archiveByContractorId = (contractorId, context) => {
+    return contractorsAPI.archiveByContractorId(contractorId, context);
+};
+
+const restoreByContractorId = (contractorId, context) => {
+    return contractorsAPI.restoreByContractorId(contractorId, context);
+};
+
+const editContractor = async (editContractorModel, context) => {
+    validateType(editContractorModel, ContractorModel);
+    return contractorsAPI.editContractor(editContractorModel, context);
+};
+
+const updateExpiryDate = async (contractorId, expiryDate, policyName) => {
+    return contractorsAPI.updateExpiryDate(contractorId, expiryDate, policyName);
+};
+
+module.exports = {
+    createContractors,
+    getContractorsByAccountId,
+    getContractorById,
+    deleteByContractorId,
+    archiveByContractorId,
+    restoreByContractorId,
+    editContractor,
+    updateExpiryDate
+};

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

@@ -1,6 +1,7 @@
 const createModel = require('./models/create.contractor.model');
+const editModel = require('./models/edit.contractor.model');
 const services = require('./api/contractors.setup');
 
-const models = { create: createModel };
+const models = { create: createModel, edit:editModel };
 
 module.exports = { services, models };

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

@@ -0,0 +1,24 @@
+const { validateType } = require('../../../../common/validations/typeValidations');
+
+function ContractorModel(contractorId, company, emailAddress, tab, tenantRecord) {
+    this.contractorId = contractorId;
+    this.company = company;
+    this.emailAddress = emailAddress;
+    this.tab = tab;
+    this.tenantRecord = tenantRecord;
+
+    validateType(tenantRecord, TenantRecordModel);
+    validateType(tab, VendorTabModel);
+}
+
+function TenantRecordModel(id, companyName, emailAddress) {
+    this.id = id;
+    this.companyName = companyName;
+    this.emailAddress = emailAddress;
+}
+
+function VendorTabModel(type){
+    this.type = type;
+}
+
+module.exports = { ContractorModel, TenantRecordModel, VendorTabModel };

package/src/saas/internal-api/projects/api/{projects.api.js → core/projects.api.js}

@@ -1,5 +1,5 @@
-const requests = require('../../common/requests');
-const { backendUrl } = require('../../../../env').getEnv();
+const requests = require('../../../common/requests');
+const { backendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
     create: `${backendUrl}/saas/project`,

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

@@ -1,7 +1,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/create.project.model');
+const accounts = require('../../../accounts/api/core/accounts.core.setup');
+const { validateType } = require('../../../../../common/validations/typeValidations');
+const CreateProjectModel = require('../../models/core/create.project.model');
 
 const getProjectsByAccountName = async (accountName, context) => {
     const accountId = accounts.getAccountId(accountName, context);
@@ -28,9 +28,20 @@ const createProject = async (createProjectModel, context) => {
     return projectsApi.create(createProjectModel, context);
 };
 
+const getOrCreateProject = async (createProjectModel, context) => {
+    const existingProjects = await getProjectsByName(createProjectModel.userId, createProjectModel.projectName, context);
+
+    if (existingProjects.length > 0) {
+        return existingProjects[0];
+    }
+
+    return createProject(createProjectModel, context);
+};
+
 module.exports = {
     getProjectsByAccountName,
     getProjectsByAccountId,
     createProject,
-    deleteProjectByName
+    deleteProjectByName,
+    getOrCreateProject
 };

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

@@ -0,0 +1,18 @@
+const requests = require('../../../common/requests');
+const { backendUrl } = require('../../../../../env').getEnv();
+
+const Endpoints = {
+    getByProjectId: projectId => `${backendUrl}/saas/project/${projectId}/settings`,
+    updateByProjectId: projectId => `${backendUrl}/saas/project/${projectId}/settings`,
+};
+
+const getProjectSettingsByProjectId = async (projectId, context) => {
+    const params = { projectId };
+    return requests.getRequestHandler(Endpoints.getByProjectId(projectId), params, context).then(res => res.data);
+};
+
+const updateProjectSettingsByProjectId = async (settings, context) => {
+    return requests.putRequestHandler(Endpoints.updateByProjectId(settings.projectId), settings, context);
+};
+
+module.exports = { getProjectSettingsByProjectId, updateProjectSettingsByProjectId };

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

@@ -0,0 +1,17 @@
+const { getProjectSettingsByProjectId, updateProjectSettingsByProjectId } = require('./project.settings.api');
+const { validateType } = require('../../../../../common/validations/typeValidations');
+const UpdateProjectSettingsModel = require('../../models/settings/update.project.settings.model');
+
+const updateProjectSettings = async (updateProjectSettingsModel, context) => {
+    validateType(updateProjectSettingsModel, UpdateProjectSettingsModel);
+    return updateProjectSettingsByProjectId(updateProjectSettingsModel, context);
+};
+
+const getProjectSettings = async (projectId, context)=>{
+    return getProjectSettingsByProjectId(projectId, context);
+};
+
+module.exports = {
+    updateProjectSettings,
+    getProjectSettings
+};

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

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

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

@@ -0,0 +1,34 @@
+
+function UpdateProjectSettingsModel({
+    autoGaps = defaultAutoGaps,
+    autoRenewels = false,
+    marketplace = defaultMarketplace,
+    ocrEnabled = false,
+    onboardingPhase = false,
+    projectId=null,
+    qrEnabled = false,
+    tenantSolution = false
+
+}) {
+    this.autoGaps = autoGaps;
+    this.autoRenewels = autoRenewels;
+    this.marketplace = marketplace;
+    this.ocrEnabled = ocrEnabled;
+    this.onboardingPhase = onboardingPhase;
+    this.projectId = projectId;
+    this.qrEnabled = qrEnabled;
+    this.tenantSolution = tenantSolution;
+}
+
+module.exports = UpdateProjectSettingsModel;
+
+const defaultMarketplace = {
+    marketplaceEnabled: false,
+    marketplacePreApproved: false,
+    marketplacePublicLink: false
+};
+const defaultAutoGaps = {
+    Guests: false,
+    Tenants: false,
+    Vendors: false
+};

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

@@ -0,0 +1,12 @@
+const requests = require('../../common/requests');
+const { backendUrl } = require('../../../../env').getEnv();
+
+const Endpoints = {
+    generateReport: reportType => `${backendUrl}/saas/integration-tests/ExportXLSXReport/${reportType}`
+};
+
+const generateReport = async (reportFilters, reportType, context) => {
+    return requests.postRequestHandler(Endpoints.generateReport(reportType), reportFilters, context).then(res => res.data);
+};
+
+module.exports = { generateReport };

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

@@ -0,0 +1,11 @@
+const reportsApi = require('./reports.api');
+const { validateType } = require('../../../../common/validations/typeValidations');
+const { ReportFilters } = require('../models/report.model');
+
+const generateReport = async (reportFilters, reportType, context) => {
+    validateType(reportFilters, ReportFilters);
+    return reportsApi.generateReport(reportFilters, reportType, context);
+};
+
+module.exports = { generateReport };
+

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

@@ -0,0 +1,11 @@
+const reportService = require('./api/reports.setup');
+const reportModels = require('./models/report.model');
+
+const services = {
+    report: reportService
+};
+const models = {
+    report: reportModels,
+};
+
+module.exports = { models, services };

package/src/saas/internal-api/reports/models/report.model.js

@@ -0,0 +1,42 @@
+const REPORT_TYPES = {
+    WAIVER_REPORT: 'WaiversReport'
+};
+
+const REPORT_COMPLIANCE_STATUSES = {
+    COMPLIANT: 'COMPLIANT',
+    NOT_COMPLIANT: 'NOT_COMPLIANT',
+    AWAITING_COI: 'AWAITING_COI',
+    WAIVED: 'WAIVED',
+    EXPIRED: 'EXPIRED',
+};
+
+const REPORT_CONTRACTOR_TYPES = {
+    VENDORS: 'Vendors',
+    TENANTS: 'Tenants',
+    GUESTS: 'Guests'
+};
+
+const ALL_REPORT_COMPLIANCE_STATUSES = [
+    REPORT_COMPLIANCE_STATUSES.COMPLIANT,
+    REPORT_COMPLIANCE_STATUSES.NOT_COMPLIANT,
+    REPORT_COMPLIANCE_STATUSES.AWAITING_COI,
+    REPORT_COMPLIANCE_STATUSES.WAIVED,
+    REPORT_COMPLIANCE_STATUSES.EXPIRED
+];
+
+const ALL_REPORT_CONTRACTOR_TYPES = [
+    REPORT_CONTRACTOR_TYPES.VENDORS,
+    REPORT_CONTRACTOR_TYPES.TENANTS,
+    REPORT_CONTRACTOR_TYPES.GUESTS
+];
+
+function ReportFilters(projects, {
+    complianceStatuses = ALL_REPORT_COMPLIANCE_STATUSES,
+    contractorTypes = ALL_REPORT_CONTRACTOR_TYPES
+}) {
+    this.projects = projects;
+    this.vendorTabTypes = contractorTypes;
+    this.complianceStatuses = complianceStatuses;
+}
+
+module.exports = { ReportFilters, REPORT_TYPES, REPORT_CONTRACTOR_TYPES, REPORT_COMPLIANCE_STATUSES };

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

@@ -3,7 +3,8 @@ const { backendUrl } = require('../../../../env').getEnv();
 
 const Endpoints = {
     create: `${backendUrl}/saas/requirement`,
-    get: `${backendUrl}/saas/requirements`,
+    getRequirementsByTabId: `${backendUrl}/saas/requirements`,
+    getRequirementById: requirementId => `${backendUrl}/saas/requirement/${requirementId}`,
     delete: requirementId => `${backendUrl}/saas/requirement/${requirementId}`,
 };
 
@@ -14,11 +15,15 @@ const createRequirement = async (createRequirementModel, context, params) => {
 };
 
 const getRequirementsByTabId = async (tabId, context) => {
-    return requests.getRequestHandler(Endpoints.get, { tabId }, context).then(res => res.data);
+    return requests.getRequestHandler(Endpoints.getRequirementsByTabId, { tabId }, context).then(res => res.data);
+};
+
+const getRequirementById = async (requirementId, context) => {
+    return requests.getRequestHandler(Endpoints.getRequirementById(requirementId), {}, context).then(res => res.data);
 };
 
 const deleteByRequirementId = async (requirementId, context) => {
     return requests.deleteRequestHandler(Endpoints.delete(requirementId), context);
 };
 
-module.exports = { createRequirement, getRequirementsByTabId, deleteByRequirementId };
+module.exports = { createRequirement, getRequirementsByTabId, deleteByRequirementId, getRequirementById };

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

@@ -12,8 +12,12 @@ const getRequirementsByTabId = async (tabId, context) => {
     return requirementsAPI.getRequirementsByTabId(tabId, context);
 };
 
+const getRequirementById = async (requirementId, context) => {
+    return requirementsAPI.getRequirementById(requirementId, context);
+};
+
 const deleteByRequirementId = (requirementId, context) => {
     return requirementsAPI.deleteByRequirementId(requirementId, context);
 };
 
-module.exports = { createRequirement, getRequirementsByTabId, deleteByRequirementId };
+module.exports = { createRequirement, getRequirementsByTabId, deleteByRequirementId, getRequirementById };

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

@@ -4,7 +4,8 @@ const { backendUrl } = require('../../../../env').getEnv();
 const Endpoints = {
     getTabsByProjectId: `${backendUrl}/saas/vendortab`,
     create: `${backendUrl}/saas/vendortab`,
-    delete: `${backendUrl}/saas/vendortab`,
+    update: `${backendUrl}/saas/vendortab`,
+    delete: `${backendUrl}/saas/vendortab`
 };
 
 const getTabsByProjectId = async (projectId, context) => {
@@ -15,8 +16,12 @@ const createTab = async (tabModel, context) => {
     return requests.postRequestHandler(Endpoints.create, tabModel, context);
 };
 
+const updateTab = async (tabModel, context) => {
+    return requests.postRequestHandler(Endpoints.update, tabModel, context);
+};
+
 const deleteTab = async (tabId, context) => {
     return requests.deleteRequestHandler(Endpoints.delete, context, {}, { tabId });
 };
 
-module.exports = { getTabsByProjectId, createTab, deleteTab };
+module.exports = { getTabsByProjectId, createTab, updateTab, deleteTab };

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

@@ -5,6 +5,11 @@ const createTab = async (projectId, tabName, tabType, context) => {
     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 getTabsByProjectId = async (projectId, context) => {
     return tabsAPI.getTabsByProjectId(projectId, context);
 };
@@ -33,6 +38,7 @@ const getOrCreateTab = async (projectId, tabName, tabType, context) => {
 module.exports = {
     getTabsByProjectId,
     createTab,
+    updateTab,
     deleteTabById,
     getOrCreateTab,
     getTabsByName

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

@@ -0,0 +1,29 @@
+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}`,
+};
+
+const invite = async (projectId, invitedUser, context) => {
+    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);
+};
+
+const getUserByEmail = async (email, context) => {
+    return requests.getRequestHandler(Endpoints.getByEmail(email), null, context).then(res => res.data);
+};
+
+const deleteUser = async (userId, context) => {
+    return requests.deleteRequestHandler(Endpoints.delete(userId), context);
+};
+
+module.exports = { invite, getUsersByProjectId, getUserByEmail, deleteUser };

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

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

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

@@ -0,0 +1,3 @@
+const services = require('./api/invite.setup');
+
+module.exports = { services };

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

@@ -36,6 +36,18 @@ const putRequestHandler = async (url, apiKey, body, headers = {}) => {
 
 };
 
+const patchRequestHandler = async (url, apiKey, body, headers = {}) => {
+    enrichApiKey(headers, apiKey);
+    try {
+        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);
+    }
+
+};
+
 const deleteRequestHandler = async (url, apiKey, headers = {}, params = {}, data = {}) => {
     enrichApiKey(headers, apiKey);
     try {
@@ -52,4 +64,10 @@ const enrichApiKey = (headers, apiKey) => {
     headers['x-api-key'] = apiKey;
 };
 
-module.exports = { getRequestHandler, postRequestHandler, putRequestHandler, deleteRequestHandler };
+module.exports = {
+    getRequestHandler,
+    postRequestHandler,
+    putRequestHandler,
+    patchRequestHandler,
+    deleteRequestHandler
+};

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

@@ -0,0 +1,15 @@
+const requests = require('../common/requests');
+const { openapiUrl } = require('../../../env').getEnv();
+const { isLocalhost } = require('../../../env');
+
+const contractorUrl = isLocalhost() ? 'contractors' : 'records';
+
+const Endpoints = {
+    getAllContractors: `${openapiUrl}/${contractorUrl}/all`,
+};
+
+const getAllContractors = async (apiKey, params) => {
+    return requests.getRequestHandler(Endpoints.getAllContractors, apiKey, params).then(res => res.data);
+};
+
+module.exports = { getAllContractors };

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

@@ -0,0 +1,11 @@
+const contractorsApi = require('./contractors.api');
+
+const getContractors = async (apiKey, { projectId, type, activationStatuses } = {}) => {
+    if (activationStatuses) {
+        activationStatuses = activationStatuses.reduce((f, s) => `${f},${s}`);
+    }
+
+    return contractorsApi.getAllContractors(apiKey, { propertyId: projectId, type, activationStatuses });
+};
+
+module.exports = { getContractors };

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

@@ -0,0 +1,38 @@
+const requests = require('../common/requests');
+const { openapiUrl } = require('../../../env').getEnv();
+
+const Endpoints = {
+    getProjectsByName: `${openapiUrl}/properties`,
+    getAllProjects: `${openapiUrl}/properties/all`,
+    getModifiedProjects: `${openapiUrl}/properties/modified`,
+    createProject: `${openapiUrl}/properties`,
+    updateProject: projectId => `${openapiUrl}/properties/${projectId}`
+};
+
+const getProjectsByName = async (apiKey, params) => {
+    return requests.getRequestHandler(Endpoints.getProjectsByName, apiKey, params).then(res => res.data);
+};
+
+const getAllProjects = async apiKey => {
+    return requests.getRequestHandler(Endpoints.getAllProjects, apiKey).then(res => res.data);
+};
+
+const getModifiedProjects = async (apiKey, params) => {
+    return requests.getRequestHandler(Endpoints.getModifiedProjects, apiKey, params).then(res => res.data);
+};
+
+const createProject = async (apiKey, project) => {
+    return requests.postRequestHandler(Endpoints.createProject, apiKey, project).then(res => res.data);
+};
+
+const updateProject = async (apiKey, projectId, projectData) => {
+    return requests.patchRequestHandler(Endpoints.updateProject(projectId), apiKey, projectData).then(res => res.data);
+};
+
+module.exports = {
+    getProjectsByName,
+    getAllProjects,
+    getModifiedProjects,
+    createProject,
+    updateProject
+};

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

@@ -0,0 +1,29 @@
+const projectsApi = require('./projects.api');
+
+const getProjectsByName = async (apiKey, name) => {
+    return projectsApi.getProjectsByName(apiKey, { name });
+};
+
+const createProject = async (apiKey, project) => {
+    return projectsApi.createProject(apiKey, project);
+};
+
+const updateProject = async (apiKey, projectId, projectData) => {
+    return projectsApi.updateProject(apiKey, projectId, projectData);
+};
+
+const getAllProjects = async apiKey => {
+    return projectsApi.getAllProjects(apiKey);
+};
+
+const getModifiedProjects = async (apiKey, timestamp) => {
+    return projectsApi.getModifiedProjects(apiKey, { timestamp });
+};
+
+module.exports = {
+    getProjectsByName,
+    createProject,
+    updateProject,
+    getAllProjects,
+    getModifiedProjects
+};

package/src/saas/openapi/requirements/index.js

@@ -0,0 +1,6 @@
+const services = require('./requirements.setup');
+
+const CopyRequirementModel = require('./models/copy.requirement.model');
+const models = { CopyRequirementModel };
+
+module.exports = { ...services, models };

package/src/saas/openapi/requirements/models/copy.requirement.model.js

@@ -0,0 +1,10 @@
+function CopyRequirementModel(sourceRequirementId, destinationTabId = null,
+    newRequirementName = null, certificateHolder = null, additionalInsured = null) {
+    this.sourceRequirementId = sourceRequirementId;
+    this.destinationTabId = destinationTabId;
+    this.newRequirementName = newRequirementName;
+    this.certificateHolder = certificateHolder;
+    this.additionalInsured = additionalInsured;
+}
+
+module.exports = CopyRequirementModel;

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

@@ -0,0 +1,13 @@
+const requests = require('../common/requests');
+const { openapiUrl } = require('../../../env').getEnv();
+
+const Endpoints = {
+    copyRequirement: sourceRequirementId => `${openapiUrl}/requirement/${sourceRequirementId}/copy`,
+};
+
+const copyRequirement = async (apiKey, sourceRequirementId, newRequirementOverrides) => {
+    return requests.postRequestHandler(Endpoints.copyRequirement(sourceRequirementId), apiKey,
+        newRequirementOverrides).then(res => res.data);
+};
+
+module.exports = { copyRequirement };

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

@@ -0,0 +1,20 @@
+const requirementsApi = require('./requirements.api');
+
+const { validateType } = require('../../../common/validations/typeValidations');
+const CopyRequirementModel = require('./models/copy.requirement.model');
+
+const copyRequirement = async (apiKey, copyRequirementModel) => {
+    validateType(copyRequirementModel, CopyRequirementModel);
+    const {
+        sourceRequirementId,
+        destinationTabId,
+        newRequirementName,
+        certificateHolder,
+        additionalInsured
+    } = copyRequirementModel;
+
+    const newRequirementOverrides = { destinationTabId, newRequirementName, certificateHolder, additionalInsured };
+    return requirementsApi.copyRequirement(apiKey, sourceRequirementId, newRequirementOverrides);
+};
+
+module.exports = { copyRequirement };

package/src/saas/thread-scheduler/runner.js

@@ -0,0 +1,17 @@
+const requests = require('../internal-api/common/requests');
+const { backendUrl, threadSchedulerSecret } = require('../../env').getEnv();
+
+const Endpoints = {
+    run: `${backendUrl}/threadSchedular/${threadSchedulerSecret}`
+};
+
+const runThreadScheduler = ({ contractorIds = null } = {}) => {
+    if (contractorIds) {
+        contractorIds = contractorIds.reduce((f, s) => `${f},${s}`);
+    }
+
+    const params = { contractorIdsList: contractorIds };
+    return requests.getRequestHandler(Endpoints.run, params);
+};
+
+module.exports = { runThreadScheduler };