@getjones/test-infra 2.3.0 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getjones/test-infra",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Providing internal and openapi interface",
   "main": "src/index.js",
   "scripts": {
@@ -15,6 +15,7 @@
     "chai": "^4.3.4",
     "dotenv": "^8.2.0",
     "enum": "^3.0.4",
+    "lodash": "^4.17.21",
     "mocha": "^8.3.2"
   },
   "devDependencies": {

package/src/common/utils/objectUtils.js

@@ -0,0 +1,9 @@
+const _ = require('lodash');
+
+const cloneObject = object => {
+	return _.cloneDeep(object);
+};
+
+module.exports = {
+	cloneObject
+};

package/src/common/utils/timeUtils.js

@@ -36,6 +36,8 @@ const getDateInOneDay = format => moment().utc().add(1, peroids.days).format(for
 const getDateinSixDays = format => moment().utc().add(6, peroids.days).format(format || formats.threadScheduler);
 const getDateinThirteenDays = format => moment().utc().add(13, peroids.days).format(format || formats.threadScheduler);
 const getDateinTwentyNineDays = format => moment().utc().add(29, peroids.days).format(format || formats.threadScheduler);
+const getOneWeekAgoDate = format => moment().utc().subtract(7, peroids.days).format(format || formats.threadScheduler);
+const getOneWeekAheadDate = format => moment().utc().add(7, peroids.days).format(format || formats.threadScheduler);
 
 const getLogTimestamp = () => {
 	return moment().format(formats.logTimeStampFormat);
@@ -163,5 +165,7 @@ module.exports = {
 	getPreviousDateByDays,
 	waitFor,
 	isDateAfterOther,
-	convertDateToNewFormat
+	convertDateToNewFormat,
+	getOneWeekAgoDate,
+	getOneWeekAheadDate
 };

package/src/defaults/configs/auditConfigs.js

@@ -0,0 +1,85 @@
+const { policyNames, attributeNames } = require('./polices');
+const { cloneObject } = require('../../common/utils/objectUtils');
+const { getOneWeekAgoDate, getOneWeekAheadDate } = require('../../common/utils/timeUtils');
+
+const DEFAULT_POLICY_DATE = '24/05/2030';
+const DEFAULT_AM_SCORE = 'A';
+const DEFAULT_POLICY_NUMBER = '12345';
+
+const {
+	certificateIssueDate,
+	generalLiability
+} = policyNames;
+
+const {
+	coverageExists,
+	policyNumber,
+	policyExpired,
+	perOccurrence,
+	perPolicy,
+	perProject,
+	perLocation,
+	eachOccurrence,
+	cancellationTerms,
+	coiAuthentication,
+	signature,
+	amScore,
+	insuredAddress,
+	insuredName
+} = attributeNames;
+
+const policySelections = {
+	YES: 'Yes',
+	NO: 'No',
+	OTHER: 'Other'
+};
+
+const getCompliantAuditConfig = ({ glPolicyNumber = DEFAULT_POLICY_NUMBER } = {}) => {
+	return cloneObject({
+		[certificateIssueDate]: DEFAULT_POLICY_DATE,
+		[insuredAddress]: policySelections.YES,
+		[insuredName]: policySelections.YES,
+		[amScore]: DEFAULT_AM_SCORE,
+		[generalLiability]: {
+			[coverageExists]: policySelections.YES,
+			[policyNumber]: glPolicyNumber,
+			[policyExpired]: DEFAULT_POLICY_DATE,
+			[perOccurrence]: policySelections.YES,
+			[perPolicy]: policySelections.YES,
+			[perProject]: policySelections.YES,
+			[perLocation]: policySelections.YES,
+			[eachOccurrence]: policySelections.YES
+		},
+		[cancellationTerms]: policySelections.YES,
+		[coiAuthentication]: policySelections.YES,
+		[signature]: policySelections.YES
+	});
+};
+
+const getNotCompliantConfig = ({ glPolicyNumber } = {}) => {
+	const compliantConfig = getCompliantAuditConfig({ glPolicyNumber });
+	compliantConfig[signature] = policySelections.NO;
+
+	return compliantConfig;
+};
+
+const getAboutExpiredConfig = ({ glPolicyNumber } = {}) => {
+	const compliantConfig = getCompliantAuditConfig({ glPolicyNumber });
+	compliantConfig[generalLiability][policyExpired] = getOneWeekAheadDate();
+
+	return compliantConfig;
+};
+
+const getExpiredConfig = ({ glPolicyNumber } = {}) => {
+	const compliantConfig = getCompliantAuditConfig({ glPolicyNumber });
+	compliantConfig[generalLiability][policyExpired] = getOneWeekAgoDate();
+
+	return compliantConfig;
+};
+
+module.exports = {
+	getCompliantAuditConfig,
+	getNotCompliantConfig,
+	getAboutExpiredConfig,
+	getExpiredConfig
+};

package/src/defaults/configs/polices.js

@@ -0,0 +1,47 @@
+const policyNames = {
+	certificateOfInsurance: 'Certificate of Insurance',
+	certificateIssueDate: 'Certificate issue date',
+	generalLiability: 'General Liability',
+	excessLiability: 'Excess Liability',
+	umbrella: 'Umbrella',
+	professionalLiability: 'Professional Liability',
+	environmentalLiability: 'Environmental Liability',
+	liquorLiability: 'Liquor Liability',
+	garageLiability: 'Garage Liability',
+	garageKeepersLiability: 'Garage Keepers Liability',
+	workersCompensation: 'Workers’ Compensation',
+	automobileLiability: 'Automobile Liability',
+	propertyInsurance: 'Property Insurance',
+	rentedLeasedEquipment: 'Rented/Leased Equipment',
+	fidelityCrime: 'Fidelity / Crime',
+	employmentPracticesLiability: 'Employment Practices Liability',
+	directorsAndOfficersLiability: 'Directors and Officers Liability',
+	cyberLiability: 'Cyber Liability',
+	waiverOfSubrogation: 'Waiver Of Subrogation',
+	agreement: 'Agreement',
+	certificateHolder: 'Certificate Holder',
+	additionalInformation: 'Additional Information',
+	additionalInsured: 'Additional Insured'
+};
+
+const attributeNames = {
+	insuredAddress: 'Insured Address',
+	insuredName: 'Insured Name',
+	amScore: 'AM Score',
+	coverageExists: 'Coverage Exists',
+	eachOccurrence: 'Each Occurrence',
+	policyNumber: 'Policy Number',
+	policyExpired: 'Policy Expiry',
+	perPolicy: 'Per Policy',
+	perProject: 'Per Project',
+	perLocation: 'Per Location',
+	perOccurrence: 'Per Occur',
+	cancellationTerms: 'Cancellation Terms',
+	coiAuthentication: 'COI authentication',
+	signature: 'Signature'
+};
+
+module.exports = {
+	policyNames,
+	attributeNames
+};

package/src/defaults/configs/requirement.js

@@ -0,0 +1,29 @@
+const { policyNames, attributeNames } = require('../configs/polices');
+const { cloneObject } = require('../../common/utils/objectUtils');
+
+const { eachOccurrence } = attributeNames;
+const { generalLiability } = policyNames;
+
+const DEFAULT_REQUIREMENT_NAME = 'Integration Requirement';
+const DEFAULT_COVERAGE_VALUE = 1000000;
+
+const getDefaultRequirementPolices = () => {
+	return cloneObject({
+		[generalLiability]: {
+			[eachOccurrence]: DEFAULT_COVERAGE_VALUE
+		}
+	});
+};
+
+const defaultRequirementConfig = () => {
+	return {
+		name: DEFAULT_REQUIREMENT_NAME,
+		policies: getDefaultRequirementPolices()
+	};
+};
+
+module.exports = {
+	name: DEFAULT_REQUIREMENT_NAME,
+	getDefaultRequirementPolices,
+	defaultRequirementConfig
+};

package/src/defaults/index.js

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

package/src/env.js

@@ -37,9 +37,21 @@ const isLocalhost = () => {
 	return privateMembers.backendUrl.includes('localhost');
 };
 
+const systemUserIdentities = {};
+
+const getSystemUserIdentity = email => {
+	return systemUserIdentities[email] || null;
+};
+
+const addUserIdentity = (email, cookie, id) => {
+	systemUserIdentities[email] = { cookie, id };
+};
+
 module.exports = {
 	init,
 	getEnv: () => privateMembers,
 	requiredValidation,
-	isLocalhost
+	isLocalhost,
+	getSystemUserIdentity,
+	addUserIdentity
 };

package/src/index.js

@@ -9,6 +9,7 @@ const init = conf => {
 };
 
 const getInternalAPI = () => {
+	const defaults = require('./defaults');
 	const auth = require('./saas/internal-api/auth');
 	const accounts = require('./saas/internal-api/accounts');
 
@@ -35,6 +36,7 @@ const getInternalAPI = () => {
 	const dbEmails = require('./saas/internal-api/dbEmails/index');
 
 	const internalAPI = {
+		defaults,
 		auth,
 		accounts,
 		projects,

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

@@ -1,12 +1,20 @@
-const { getEnv, requiredValidation } = require('../../../../env');
+const { getEnv, requiredValidation, getSystemUserIdentity, addUserIdentity } = require('../../../../env');
 const { credentials } = getEnv();
 const authApi = require('./auth.api');
 
 const getAuthCookie = async (email, password) => {
+	const systemUser = getSystemUserIdentity(email);
+
+	if (systemUser) {
+		return systemUser.cookie;
+	}
+
 	try {
 		const response = await authApi.login(email, password);
 		const authCookie = response.headers['set-cookie'].find(item => item.startsWith('JonesToken='));
 
+		addUserIdentity(email, authCookie, response.data.id);
+
 		return authCookie;
 	} catch (error) {
 		throw new Error(`Failed to login to email:${email}`, error);
@@ -50,26 +58,10 @@ const getOperatorCookie = () => {
 	return getAuthCookie(operatorUser, operatorPassword);
 };
 
-const getAuditorId = async () => {
-	const { auditorUser, auditorPassword } = credentials;
-	requiredValidation({
-		'credentials.auditorUser': auditorUser,
-		'credentials.auditorPassword': auditorPassword
-	});
-
-	try {
-		const response = await authApi.login(auditorUser, auditorPassword);
-		return response.data.id;
-	} catch (error) {
-		throw new Error('Failed to get auditor id', error);
-	}
-};
-
 module.exports = {
 	getAuthCookie,
 	getVendorHubAuthCookie,
 	getIcsCookie,
 	getAuditorCookie,
-	getOperatorCookie,
-	getAuditorId
+	getOperatorCookie
 };

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

@@ -1,6 +1,5 @@
 const requests = require('../../../../../common/requests/cookieAuth/requests');
 const { backendUrl } = require('../../../../../env').getEnv();
-const { createAuditEntity } = require('../../utils/util');
 
 const Endpoints = {
 	auditorContractorList: `${backendUrl}/saas/auditor/contractors`,

package/src/saas/internal-api/compliance/utils/util.js

@@ -2,7 +2,8 @@ const { AUDIT_ENTITY_STATUSES, DEFAULT_POLICY_ID, VALID_SCORES } = require('../c
 const { isObject, isArray } = require('../../../../common/utils/dataTypeUtils');
 const timeUtils = require('../../../../common/utils/timeUtils');
 const auditModels = require('../models/audit/audit.model');
-const auth = require('../../auth');
+const { getEnv, getSystemUserIdentity } = require('../../../../env');
+const { credentials } = getEnv();
 
 const emptyValue = '';
 
@@ -67,7 +68,7 @@ const getParsedConfig = function(config) {
 				}
 
 				if (isArray(attributes[attributeName])) {
-					selection.status = AUDIT_ENTITY_STATUSES[ attributes[attributeName][0] ];
+					selection.status = AUDIT_ENTITY_STATUSES[ (attributes[attributeName][0]).toUpperCase() ];
 					selection.value = attributes[attributeName][1].replace('$', emptyValue);
 				} else {
 					// Special statuses switch
@@ -97,10 +98,10 @@ const getParsedConfig = function(config) {
 			certificateEndorsmentsList.includes(field) && (selection.policyName = field);
 
 			if (isArray(config[field])) {
-				selection.status = AUDIT_ENTITY_STATUSES[ config[field][0] ];
+				selection.status = AUDIT_ENTITY_STATUSES[ (config[field][0]).toUpperCase() ];
 				selection.value = config[field][1]; // Ok to be undefined
 			} else {
-				selection.status = AUDIT_ENTITY_STATUSES[ config[field] ] || AUDIT_ENTITY_STATUSES.YES;
+				selection.status = AUDIT_ENTITY_STATUSES[ (config[field]).toUpperCase() ] || AUDIT_ENTITY_STATUSES.YES;
 				selection.value = getValueBySelection(config[field]);
 			}
 
@@ -127,7 +128,8 @@ const createAuditEntity = (
 };
 
 const getAuditorId = () => {
-	return auth.services.getAuditorId();
+	const auditorIdentity = getSystemUserIdentity(credentials.auditorUser);
+	return auditorIdentity.id;
 };
 
 module.exports = {

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

@@ -5,6 +5,8 @@ const Endpoints = {
 	create: `${backendUrl}/saas/requirement`,
 	getRequirementsByTabId: `${backendUrl}/saas/requirements`,
 	getRequirementById: requirementId => `${backendUrl}/saas/requirement/${requirementId}`,
+	update: `${backendUrl}/saas/requirement/linked/edit`,
+	updateWithNotification: `${backendUrl}/saas/requirement/linked/edit/notify`,
 	delete: requirementId => `${backendUrl}/saas/requirement/${requirementId}`
 };
 
@@ -17,12 +19,27 @@ const getRequirementsByTabId = (tabId, context) => {
 	return requests.getRequestHandler(Endpoints.getRequirementsByTabId, { tabId }, context);
 };
 
-const getRequirementById = (requirementId, context) => {
-	return requests.getRequestHandler(Endpoints.getRequirementById(requirementId), {}, context);
+const getRequirementById = (requirementId, context, isPermanentLink = false) => {
+	return requests.getRequestHandler(Endpoints.getRequirementById(requirementId), { isPermanentLink }, context);
+};
+
+const updateRequirement = (updateRequirementModel, tabId, context) => {
+	return requests.postRequestHandler(Endpoints.update, updateRequirementModel, context, {}, { tabId });
+};
+
+const updateRequirementWithNotification = (updateRequirementModel, context) => {
+	return requests.postRequestHandler(Endpoints.updateWithNotification, updateRequirementModel, context);
 };
 
 const deleteByRequirementId = (requirementId, context) => {
 	return requests.deleteRequestHandler(Endpoints.delete(requirementId), context);
 };
 
-module.exports = { createRequirement, getRequirementsByTabId, deleteByRequirementId, getRequirementById };
+module.exports = {
+	createRequirement,
+	getRequirementsByTabId,
+	getRequirementById,
+	updateRequirement,
+	updateRequirementWithNotification,
+	deleteByRequirementId
+};

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

@@ -1,5 +1,6 @@
 const requirementsAPI = require('./requirements.api');
 const { CreateRequirementModel } = require('../models/create.requirement.model');
+const { UpdateRequirementModel } = require('../models/update.requirement.model');
 const requirementUtils = require('../utils/utils');
 
 const { validateType } = require('../../../../common/validations/typeValidations');
@@ -13,11 +14,11 @@ const getRequirementsByTabId = (tabId, context) => {
 	return requirementsAPI.getRequirementsByTabId(tabId, context);
 };
 
-const getRequirementById = (requirementId, context) => {
-	return requirementsAPI.getRequirementById(requirementId, context);
+const getRequirementById = (requirementId, context, isPermanentLink = false) => {
+	return requirementsAPI.getRequirementById(requirementId, context, isPermanentLink);
 };
 
-const getRequirementByName = async (tabId, requirementName, context) => {
+const getRequirementByName = async (tabId, requirementName, context, isPermanentLink = false) => {
 	const { data: requirementList } = await getRequirementsByTabId(tabId, context);
 
 	const requirement = requirementList.find(req => req.name === requirementName);
@@ -26,7 +27,7 @@ const getRequirementByName = async (tabId, requirementName, context) => {
 		return null;
 	}
 
-	const requirementResponse = await getRequirementById(requirement.id, context);
+	const requirementResponse = await getRequirementById(requirement.id, context, isPermanentLink);
 	return requirementResponse.data.requirement;
 };
 
@@ -39,7 +40,7 @@ const getOrCreateRequirement = async (requirement, tabId, context) => {
 	let existingRequirement = await getRequirementByName(tabId, requirement.name, context);
 
 	if (!existingRequirement) {
-		const createRequirementModel = getCreateRequirementModel(requirement.policies, requirement.name);
+		const createRequirementModel = getCreateRequirementModel(requirement);
 		await createRequirement(createRequirementModel, tabId, context);
 		existingRequirement = await getRequirementByName(tabId, requirement.name, context);
 	}
@@ -47,6 +48,16 @@ const getOrCreateRequirement = async (requirement, tabId, context) => {
 	return existingRequirement;
 };
 
+const updateRequirement = (updateRequirementModel, tabId, context) => {
+	validateType(updateRequirementModel, UpdateRequirementModel);
+	return requirementsAPI.updateRequirement(updateRequirementModel, tabId, context);
+};
+
+const updateRequirementWithNotification = (updateRequirementModel, context) => {
+	validateType(updateRequirementModel, UpdateRequirementModel);
+	return requirementsAPI.updateRequirementWithNotification(updateRequirementModel, context);
+};
+
 const deleteByRequirementId = (requirementId, context) => {
 	return requirementsAPI.deleteByRequirementId(requirementId, context);
 };
@@ -56,8 +67,15 @@ const deleteRequirementByName = async (requirementName, tabId, context) => {
 	return deleteByRequirementId(requirementToDelete.id, context);
 };
 
-const getCreateRequirementModel = (requirementConfig, requirementName) => {
-	return requirementUtils.getCreateRequirementModel(requirementConfig, requirementName);
+const getCreateRequirementModel = requirement => {
+	return requirementUtils.getCreateRequirementModel(requirement);
+};
+
+const getUpdatedRequirementModel = async (requirementId, requirementPolicies, requirementName, accountId, projectId, tabId, context) => {
+	const getRequirementData = await getRequirementByName(tabId, requirementName, context);
+	const dateModified = getRequirementData.dateModified;
+
+	return requirementUtils.getUpdateRequirementModel(requirementId, requirementPolicies, requirementName, accountId, projectId, tabId, dateModified);
 };
 
 module.exports = {
@@ -67,8 +85,10 @@ module.exports = {
 	getRequirementIdByName,
 	getRequirementsByTabId,
 	getOrCreateRequirement,
+	updateRequirement,
+	updateRequirementWithNotification,
 	deleteByRequirementId,
 	deleteRequirementByName,
-
-	getCreateRequirementModel
+	getCreateRequirementModel,
+	getUpdatedRequirementModel
 };

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

@@ -0,0 +1,6 @@
+const REQUIREMENT_SHARING_LEVELS = {
+	TAB: 'Tab',
+	ACCOUNT: 'Account'
+};
+
+module.exports = { REQUIREMENT_SHARING_LEVELS };

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

@@ -1,6 +1,8 @@
 const createModel = require('./models/create.requirement.model');
+const updateModel = require('./models/update.requirement.model');
+const policyModel = require('./models/policy.model');
 const services = require('./api/requirements.service');
 
-const models = { create: createModel };
+const models = { create: createModel, update: updateModel, policy: policyModel };
 
 module.exports = { services, models };

package/src/saas/internal-api/requirements/models/create.requirement.model.js

@@ -1,46 +1,17 @@
-const Enum = require('enum');
 const { validateType } = require('../../../../common/validations/typeValidations');
+const { PolicyModel } = require('./policy.model');
 
-const DEFAULT_REQUIREMENT_TYPE = 'REQUIREMENT';
+const { REQUIREMENT_SHARING_LEVELS } = require('../consts/consts');
 
 class CreateRequirementModel {
-	constructor(name, policies) {
+	constructor(name, policies, sharingLevel = REQUIREMENT_SHARING_LEVELS.TAB) {
 		this.name = name;
 		this.policies = policies;
-		this.requirementType = DEFAULT_REQUIREMENT_TYPE;
+		this.sharingLevel = sharingLevel;
 
 		validateType(policies, Array);
-		policies && validateType(policies[0], Policy);
+		policies && validateType(policies[0], PolicyModel);
 	}
 }
 
-class Policy {
-	constructor(name, attributes) {
-		this.policyName = name;
-		this.attributes = attributes;
-
-		validateType(attributes, Array);
-		attributes && validateType(attributes[0], Attribute);
-	}
-}
-
-class Attribute {
-	constructor(name, type, values) {
-		this.attributeName = name;
-		this.type = type.value;
-		this.values = values.map(value => ({ value }));
-
-		if (!AttributeTypes.get(type) || !AttributeTypes.get(type.key)) {
-			throw TypeError(`Expected type to be instance of: ${AttributeTypes.name}`);
-		}
-	}
-}
-
-const AttributeTypes = new Enum({
-	'ENDORSMENT': 'endorsment',
-	'LIMIT': 'limit',
-	'BOOLEAN': 'boolean',
-	'MULTIPLE': 'multiple'
-}, { name: 'AttributeTypes' });
-
-module.exports = { CreateRequirementModel, Policy, Attribute, AttributeTypes };
+module.exports = { CreateRequirementModel };

package/src/saas/internal-api/requirements/models/policy.model.js

@@ -0,0 +1,32 @@
+const Enum = require('enum');
+const { validateType } = require('../../../../common/validations/typeValidations');
+
+class PolicyModel {
+	constructor(name, attributes) {
+		this.policyName = name;
+		this.attributes = attributes;
+		validateType(attributes, Array);
+		attributes && validateType(attributes[0], AttributeModel);
+	}
+}
+
+class AttributeModel {
+	constructor(name, type, values) {
+		this.attributeName = name;
+		this.type = type.value;
+		this.values = values.map(value => ({ value }));
+
+		if (!AttributeTypes.get(type) || !AttributeTypes.get(type.key)) {
+			throw TypeError(`Expected type to be instance of: ${AttributeTypes.name}`);
+		}
+	}
+}
+
+const AttributeTypes = new Enum({
+	'ENDORSMENT': 'endorsment',
+	'LIMIT': 'limit',
+	'BOOLEAN': 'boolean',
+	'MULTIPLE': 'multiple'
+}, { name: 'AttributeTypes' });
+
+module.exports = { PolicyModel, AttributeModel, AttributeTypes };

package/src/saas/internal-api/requirements/models/update.requirement.model.js

@@ -0,0 +1,21 @@
+const { validateType } = require('../../../../common/validations/typeValidations');
+const { PolicyModel } = require('./policy.model');
+const DEFAULT_REQUIREMENT_TYPE = 'REQUIREMENT';
+
+class UpdateRequirementModel {
+	constructor(id, accountId, projectId, tabId, name, policies, dateModified) {
+		this.id = id;
+		this.userId = accountId;
+		this.projectId = projectId;
+		this.tabId = tabId;
+		this.name = name;
+		this.policies = policies;
+		this.requirementType = DEFAULT_REQUIREMENT_TYPE;
+		this.dateModified = dateModified;
+
+		validateType(policies, Array);
+		policies && validateType(policies[0], PolicyModel);
+	}
+}
+
+module.exports = { UpdateRequirementModel };

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

@@ -1,6 +1,9 @@
-const models = require('../models/create.requirement.model');
 const attributeTypes = require('../consts/attributeTypes.json');
 const dataTypeUtils = require('../../../../common/utils/dataTypeUtils');
+const { UpdateRequirementModel } = require('../models/update.requirement.model');
+const { AttributeModel, PolicyModel, AttributeTypes } = require('../models/policy.model');
+const { CreateRequirementModel } = require('../models/create.requirement.model');
+const { REQUIREMENT_SHARING_LEVELS } = require('../consts/consts');
 
 const convertNumericValuesToNumberType = function(value) {
 	if (dataTypeUtils.isString(value) && value.startsWith('$')) {
@@ -14,22 +17,22 @@ const preparePolicyAttributesTypes = function(value) {
 	const attributesValue = convertNumericValuesToNumberType(value);
 
 	if (dataTypeUtils.isNumber(attributesValue)) {
-		return models.AttributeTypes.get(attributeTypes.limit);
+		return AttributeTypes.get(attributeTypes.limit);
 	}
 
 	if (dataTypeUtils.isBoolean(attributesValue)) {
-		return models.AttributeTypes.get(attributeTypes.boolean);
+		return AttributeTypes.get(attributeTypes.boolean);
 	}
 
-	return models.AttributeTypes.get(attributeTypes.multiple);
+	return AttributeTypes.get(attributeTypes.multiple);
 };
 
 const prepareEndorsmentAttributesTypes = function(value) {
 	if (dataTypeUtils.isBoolean(value)) {
-		return models.AttributeTypes.get(attributeTypes.boolean);
+		return AttributeTypes.get(attributeTypes.boolean);
 	}
 
-	return models.AttributeTypes.get(attributeTypes.endorsment);
+	return AttributeTypes.get(attributeTypes.endorsment);
 };
 
 const parseRequirementConfig = function(config) {
@@ -71,18 +74,28 @@ const parseRequirementConfig = function(config) {
 const getPolicyModel = function(policyData) {
 	const attributes = policyData.attributes;
 	const attributeModels = attributes.map(attribute =>
-		new models.Attribute(attribute.name, attribute.type, attribute.values));
+		new AttributeModel(attribute.name, attribute.type, attribute.values));
 
-	return new models.Policy(policyData.name, attributeModels);
+	return new PolicyModel(policyData.name, attributeModels);
 };
 
-const getCreateRequirementModel = function(requirementConfig, requirementName) {
-	const policies = parseRequirementConfig(requirementConfig);
+const getCreateRequirementModel = function(requirement) {
+	const { policies, name, sharingLevel } = requirement;
+
+	const parsedPolicies = parseRequirementConfig(policies);
+	const policyModels = parsedPolicies.map(policy => getPolicyModel(policy));
+
+	return new CreateRequirementModel(name, policyModels, sharingLevel);
+};
+
+const getUpdateRequirementModel = function(requirementId, requirementPolicies, requirementName, accountId, projectId, tabId, dateModified) {
+	const policies = parseRequirementConfig(requirementPolicies);
 	const policyModels = policies.map(policy => getPolicyModel(policy));
 
-	return new models.CreateRequirementModel(requirementName, policyModels);
+	return new UpdateRequirementModel(requirementId, accountId, projectId, tabId, requirementName, policyModels, dateModified);
 };
 
 module.exports = {
-	getCreateRequirementModel
+	getCreateRequirementModel,
+	getUpdateRequirementModel
 };