@getjones/test-infra 1.0.12 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getjones/test-infra",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "Providing internal and openapi interface",
   "main": "src/index.js",
   "scripts": {
@@ -10,10 +10,11 @@
   "license": "ISC",
   "dependencies": {
     "axios": "^0.21.1",
-    "dotenv": "^8.2.0",
-    "mocha": "^8.3.2",
     "chai": "^4.3.4",
-    "http-status-code": "^2.1.0"
+    "dotenv": "^8.2.0",
+    "enum": "^3.0.4",
+    "http-status-code": "^2.1.0",
+    "mocha": "^8.3.2"
   },
   "devDependencies": {
     "eslint": "^7.22.0",

package/src/index.js

@@ -11,6 +11,8 @@ const init = conf => {
 
     const projects = require('./internal-api/projects/projects.setup');
     const tabs = require('./internal-api/tabs/tabs.setup');
+    const requirements = require('./internal-api/requirements');
+    const contractors = require('./internal-api/contractors');
 
     const accounts = {
         core: accountsCore,
@@ -21,7 +23,14 @@ const init = conf => {
         accountsOpenAPI
     };
 
-    const internalAPI = { auth, accounts, projects, tabs };
+    const internalAPI = {
+        auth,
+        accounts,
+        projects,
+        tabs,
+        requirements,
+        contractors
+    };
     return { internalAPI };
 };
 

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

@@ -12,10 +12,10 @@ const getRequestHandler = async (url, params = {}, context = null, headers = {})
 
 };
 
-const postRequestHandler = async (url, body, context = null, headers = {}) => {
+const postRequestHandler = async (url, body, context = null, headers = {}, params = {}) => {
     enrichCookie(headers, context);
     try {
-        const response = await axios.post(url, body, { headers });
+        const response = await axios.post(url, body, { headers, params });
         return response;
     } catch (error) {
         const message = error.response.data && JSON.stringify(error.response.data) || error.message;

package/src/internal-api/common/validations.js

@@ -0,0 +1,7 @@
+const validateType = (input, expectedType) => {
+    if (!(input instanceof expectedType)) {
+        throw TypeError(`Type should be: ${expectedType}`);
+    }
+};
+
+module.exports = { validateType };

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

@@ -0,0 +1,22 @@
+const requests = require('../../common/requests');
+const { backendUrl } = require('../../../env').getEnv();
+
+const Endpoints = {
+    create: `${backendUrl}/saas/contractors/invite`,
+    get: `${backendUrl}/saas/contractors`,
+    delete: contractorId => `${backendUrl}/saas/contractor/${contractorId}`,
+};
+
+const createContractors = async (createContractorModel, context) => {
+    return requests.postRequestHandler(Endpoints.create, createContractorModel, context).then(res => res.data);
+};
+
+const getContractorsByAccountId = async (params, context) => {
+    return requests.getRequestHandler(Endpoints.get, params, context).then(res => res.data);
+};
+
+const deleteByContractorId = async (contractorId, context) => {
+    return requests.deleteRequestHandler(Endpoints.delete(contractorId), context);
+};
+
+module.exports = { createContractors, getContractorsByAccountId, deleteByContractorId };

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

@@ -0,0 +1,18 @@
+const contractorsAPI = require('./contractors.api');
+const { CreateContractorModel } = require('../models/create.contractor.model');
+const { validateType } = require('../../common/validations');
+
+const createContractors = async (createContractorsModel, context) => {
+    validateType(createContractorsModel, CreateContractorModel);
+    return contractorsAPI.createContractors(createContractorsModel, context);
+};
+
+const getContractorsByAccountId = async (accountId, context) => {
+    return contractorsAPI.getContractorsByAccountId({ accountId }, context);
+};
+
+const deleteByContractorId = (contractorId, context) => {
+    return contractorsAPI.deleteByContractorId(contractorId, context);
+};
+
+module.exports = { createContractors, getContractorsByAccountId, deleteByContractorId };

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

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

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

@@ -0,0 +1,20 @@
+const { validateType } = require('../../common/validations');
+
+function CreateContractorModel(requirementId, inviterEmail, vendorsInfo) {
+    this.reqId = requirementId;
+    this.inviterEmail = inviterEmail;
+    this.vendorInfo = vendorsInfo;
+    this.disableMail = true;
+    this.sendCovid19Form = false;
+
+    validateType(vendorsInfo, Array);
+    vendorsInfo && validateType(vendorsInfo[0], ContractorInfo);
+}
+
+function ContractorInfo(email, companyName) {
+    this.email = email;
+    this.companyName = companyName;
+    this.title = email;
+}
+
+module.exports = { CreateContractorModel, ContractorInfo };

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

@@ -0,0 +1,24 @@
+const requests = require('../../common/requests');
+const { backendUrl } = require('../../../env').getEnv();
+
+const Endpoints = {
+    create: `${backendUrl}/saas/requirement`,
+    get: `${backendUrl}/saas/requirements`,
+    delete: requirementId => `${backendUrl}/saas/requirement/${requirementId}`,
+};
+
+const createRequirement = async (createRequirementModel, context, params) => {
+    return requests.postRequestHandler(Endpoints.create, createRequirementModel, context, {}, params).then(
+        res => res.data
+    );
+};
+
+const getRequirementsByTabId = async (tabId, context) => {
+    return requests.getRequestHandler(Endpoints.get, { tabId }, context).then(res => res.data);
+};
+
+const deleteByRequirementId = async (requirementId, context) => {
+    return requests.deleteRequestHandler(Endpoints.delete(requirementId), context);
+};
+
+module.exports = { createRequirement, getRequirementsByTabId, deleteByRequirementId };

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

@@ -0,0 +1,19 @@
+const requirementsAPI = require('./requirements.api');
+const { CreateRequirementModel } = require('../models/create.requirement.model');
+const { validateType } = require('../../common/validations');
+
+const createRequirement = async (createRequirementModel, context) => {
+    validateType(createRequirementModel, CreateRequirementModel);
+    const params = { 'leaseId': '' };
+    return requirementsAPI.createRequirement(createRequirementModel, context, params);
+};
+
+const getRequirementsByTabId = async (tabId, context) => {
+    return requirementsAPI.getRequirementsByTabId(tabId, context);
+};
+
+const deleteByRequirementId = (requirementId, context) => {
+    return requirementsAPI.deleteByRequirementId(requirementId, context);
+};
+
+module.exports = { createRequirement, getRequirementsByTabId, deleteByRequirementId };

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

@@ -0,0 +1,6 @@
+const createModel = require('./models/create.requirement.model');
+const api = require('./api/requirements.setup');
+
+const models = { create: createModel };
+
+module.exports = { api, models };

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

@@ -0,0 +1,46 @@
+const Enum = require('enum');
+const { validateType } = require('../../common/validations');
+
+const DEFAULT_REQUIREMENT_TYPE = 'REQUIREMENT';
+
+function CreateRequirementModel(accountId, projectId, tabId, name, policies) {
+    this.userId = accountId;
+    this.projectId = projectId;
+    this.tabId = tabId;
+    this.name = name;
+    this.policies = policies;
+    this.requirementType = DEFAULT_REQUIREMENT_TYPE;
+
+    validateType(policies, Array);
+    policies && validateType(policies[0], Policy);
+
+}
+
+function Policy(name, attributes) {
+    this.policyName = name;
+    this.attributes = attributes;
+
+    validateType(attributes, Array);
+    attributes && validateType(attributes[0], Attribute);
+}
+
+function Attribute(name, type, values) {
+    this.attributeName = name;
+    this.type = type.value;
+    this.values = values.map(function(value) {
+        return { 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 };