@getjones/test-infra 1.2.5 → 1.2.7

package/package.json

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

package/src/common/requests/apiKeyAuth/requests.js

@@ -0,0 +1,38 @@
+const requestHandler = require('./../requestHandlers');
+
+const getRequestHandler = (url, apiKey, params = {}, headers = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.getRequestHandler(url, headers, params);
+};
+
+const postRequestHandler = (url, apiKey, body, headers = {}, params = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.postRequestHandler(url, body, headers, params);
+};
+
+const putRequestHandler = (url, apiKey, body, headers = {}, params = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.putRequestHandler(url, body, headers, params);
+};
+
+const patchRequestHandler = (url, apiKey, body, headers = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.patchRequestHandler(url, body, headers);
+};
+
+const deleteRequestHandler = (url, apiKey, headers = {}, params = {}, data = {}) => {
+	enrichApiKey(headers, apiKey);
+	return requestHandler.deleteRequestHandler(url, headers, params, data);
+};
+
+const enrichApiKey = (headers, apiKey) => {
+	headers['x-api-key'] = apiKey;
+};
+
+module.exports = {
+	getRequestHandler,
+	postRequestHandler,
+	putRequestHandler,
+	patchRequestHandler,
+	deleteRequestHandler
+};

package/src/common/requests/cookieAuth/requests.js

@@ -0,0 +1,40 @@
+const requestHandler = require('./../requestHandlers');
+
+const getRequestHandler = (url, params = {}, context = null, headers = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.getRequestHandler(url, headers, params);
+};
+
+const postRequestHandler = (url, body, context = null, headers = {}, params = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.postRequestHandler(url, body, headers, params);
+};
+
+const putRequestHandler = (url, body, context = null, headers = {}, params = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.putRequestHandler(url, body, headers, params);
+};
+
+const patchRequestHandler = (url, context, body, headers = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.patchRequestHandler(url, body, headers);
+};
+
+const deleteRequestHandler = (url, context = null, headers = {}, params = {}, data = {}) => {
+	enrichCookie(headers, context);
+	return requestHandler.deleteRequestHandler(url, headers, params, data);
+};
+
+const enrichCookie = (headers, context) => {
+	if (context) {
+		headers.Cookie = context;
+	}
+};
+
+module.exports = {
+	getRequestHandler,
+	postRequestHandler,
+	putRequestHandler,
+	patchRequestHandler,
+	deleteRequestHandler
+};

package/src/common/requests/requestHandlers.js

@@ -0,0 +1,60 @@
+const axios = require('axios');
+const errorValidation = require('../validations/errorValidation');
+
+const getRequestHandler = async (url, headers = {}, params = {}) => {
+	try {
+		const response = await axios.get(url, { params, headers });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+const postRequestHandler = async (url, body, headers = {}, params = {}) => {
+	try {
+		const response = await axios.post(url, body, { headers, params });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+const putRequestHandler = async (url, body, headers = {}, params = {}) => {
+	try {
+		const response = await axios.put(url, body, { headers, params });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+const patchRequestHandler = async (url, body, headers = {}) => {
+	try {
+		const response = await axios.patch(url, body, { headers });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+const deleteRequestHandler = async (url, headers = {}, params = {}, data = {}) => {
+	try {
+		const response = await axios.delete(url, { params, headers, data });
+		return response;
+	} catch (error) {
+		errorValidation.validateClientErrorResponseStatus(error);
+		return error.response;
+	}
+};
+
+module.exports = {
+	getRequestHandler,
+	postRequestHandler,
+	putRequestHandler,
+	patchRequestHandler,
+	deleteRequestHandler
+};

package/src/common/validations/errorValidation.js

@@ -1,16 +1,16 @@
-const responseStatusCodes = require('../httpResponseStatusCodes.json');
+const httpResponseStatusCodes = require('../httpResponseStatusCodes.json');
 
-const validateError = error => {
-    if (!error.response || !isClientErrorCode(error.response.status)) {
-        throw error;
-    }
+const validateClientErrorResponseStatus = error => {
+	if (!error.response || !isResponseStatusClientErrorCode(error.response.status)) {
+		throw error;
+	}
 };
 
-const isClientErrorCode = httpStatusCode => {
-    const minClientErrorCode = responseStatusCodes.BAD_REQUEST;
-    const maxClientErrorCode = responseStatusCodes.CLIENT_CLOSED_REQUEST;
+const isResponseStatusClientErrorCode = httpResponseStatusCode => {
+	const minClientErrorCode = httpResponseStatusCodes.BAD_REQUEST;
+	const maxClientErrorCode = httpResponseStatusCodes.CLIENT_CLOSED_REQUEST;
 
-    return httpStatusCode >= minClientErrorCode && httpStatusCode <= maxClientErrorCode;
+	return httpResponseStatusCode >= minClientErrorCode && httpResponseStatusCode <= maxClientErrorCode;
 };
 
-module.exports = { validateError };
+module.exports = { validateClientErrorResponseStatus };

package/src/common/validations/typeValidations.js

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

package/src/index.js

@@ -4,9 +4,8 @@ const init = conf => {
 	env.init(conf);
 	const internalAPI = getInternalAPI();
 	const openAPI = getOpenAPI();
-	const threadScheduler = require('./saas/thread-scheduler/runner');
 
-	return { internalAPI, openAPI, threadScheduler };
+	return { internalAPI, openAPI };
 };
 
 const getInternalAPI = () => {
@@ -26,6 +25,9 @@ const getInternalAPI = () => {
 	const reports = require('./saas/internal-api/reports');
 	const charts = require('./saas/internal-api/homepageCharts');
 
+	const globalRecord = require('./saas/internal-api/globalRecord');
+
+	const threadScheduler = require('./saas/internal-api/thread-scheduler/runner');
 
 	const internalAPI = {
 		auth,
@@ -38,7 +40,9 @@ const getInternalAPI = () => {
 		compliance,
 		reports,
 		users,
-		charts
+		charts,
+		globalRecord,
+		threadScheduler
 	};
 
 	return internalAPI;

package/src/saas/internal-api/accounts/api/core/accounts.core.api.js

@@ -1,28 +1,28 @@
-const requests = require('../../../common/requests');
+const requests = require('../../../../../common/requests/cookieAuth/requests');
 const { backendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
-    getAccount: `${backendUrl}/saas/accounts`,
-    create: `${backendUrl}/saas/createaccount`,
-    delete: `${backendUrl}/saas/account`,
-    edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
+	getAccount: `${backendUrl}/saas/accounts`,
+	create: `${backendUrl}/saas/createaccount`,
+	delete: `${backendUrl}/saas/account`,
+	edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
 };
 
-const create = async (account, context) => {
-    return requests.postRequestHandler(Endpoints.create, account, context).then(res => res.data);
+const create = (account, context) => {
+	return requests.postRequestHandler(Endpoints.create, account, context);
 };
 
-const deleteAccount = async (accountId, context) => {
-    return requests.deleteRequestHandler(Endpoints.delete, context, {}, { 'userId': accountId });
+const deleteAccount = (accountId, context) => {
+	return requests.deleteRequestHandler(Endpoints.delete, context, {}, { 'userId': accountId });
 };
 
-const updateAccountSettings = async (accountId, settings, context) => {
-    return requests.putRequestHandler(Endpoints.edit(accountId), { accountId, ...settings }, context);
+const updateAccountSettings = (accountId, settings, context) => {
+	return requests.putRequestHandler(Endpoints.edit(accountId), { accountId, ... settings }, context);
 };
 
-const getByName = async (accountName, context) => {
-    const params = { name: accountName };
-    return requests.getRequestHandler(Endpoints.getAccount, params, context).then(res => res.data);
+const getByName = (accountName, context) => {
+	const params = { name: accountName };
+	return requests.getRequestHandler(Endpoints.getAccount, params, context);
 };
 
 module.exports = { create, getByName, deleteAccount, updateAccountSettings };

package/src/saas/internal-api/accounts/api/core/accounts.core.setup.js

@@ -6,67 +6,67 @@ const { validateType } = require('../../../../../common/validations/typeValidati
 const { accountCreationSecret } = env.getEnv();
 
 const createAccount = async (createAccountModel, context) => {
-    validateType(createAccountModel, CreateAccountModel);
+	validateType(createAccountModel, CreateAccountModel);
 
-    env.requiredValidation({
-        accountCreationSecret: accountCreationSecret,
-        'credentials.strongPassword': createAccountModel.password
-    });
+	env.requiredValidation({
+		accountCreationSecret: accountCreationSecret,
+		'credentials.strongPassword': createAccountModel.password
+	});
 
-    return await accountsAPI.create(createAccountModel, context);
+	return accountsAPI.create(createAccountModel, context);
 };
 
 const getAccount = async (accountName, context) => {
-    const existingAccounts = await accountsAPI.getByName(accountName, context);
+	const response = await accountsAPI.getByName(accountName, context);
 
-    if (!existingAccounts || existingAccounts.length === 0) {
-        return null;
-    }
+	if (!response.data || !response.data.length) {
+		return null;
+	}
 
-    if (existingAccounts.length > 1) {
-        throw new Error(`Got more than one account with the name: ${accountName}. IDs: ${existingAccounts.map(item => item.userId).join(', ')}`);
-    }
+	if (response.data.length > 1) {
+		throw new Error(`Got more than one account with the name: ${accountName}. IDs: ${existingAccounts.map(item => item.userId).join(', ')}`);
+	}
 
-    return existingAccounts[0];
+	return response.data[0];
 };
 
 const getOrCreateAccount = async (createAccountModel, context) => {
-    validateType(createAccountModel, CreateAccountModel);
-    const existingAccount = await getAccount(createAccountModel.companyName, context);
+	validateType(createAccountModel, CreateAccountModel);
+	const existingAccount = await getAccount(createAccountModel.companyName, context);
 
-    if (existingAccount) {
-        return existingAccount;
-    }
+	if (existingAccount) {
+		return existingAccount;
+	}
 
-    return await createAccount(createAccountModel, context);
+	const newAccountResponse = await createAccount(createAccountModel, context);
+	return newAccountResponse.data;
 };
 
 const getAccountId = async (accountName, context) => {
-    const account = await getAccount(accountName, context);
+	const account = await getAccount(accountName, context);
 
-    if (!account) {
-        console.error(`Account ${accountName} does not exist`);
-        return null;
-    }
+	if (!account) {
+		console.error(`Account ${accountName} does not exist`);
+		return null;
+	}
 
-    return account.userId;
+	return account.userId;
 };
 
 const deleteAccountByName = async (accountName, context) => {
-    const accountId = await getAccountId(accountName, context);
-    return accountsAPI.deleteAccount(accountId, context);
+	const accountId = await getAccountId(accountName, context);
+	return accountsAPI.deleteAccount(accountId, context);
 };
 
 const deleteAccountById = async (accountId, context) => {
-    return accountsAPI.deleteAccount(accountId, context);
+	return accountsAPI.deleteAccount(accountId, context);
 };
 
 module.exports = {
-    getAccount,
-    getOrCreateAccount,
-    getAccountId,
-    createAccount,
-    deleteAccountByName,
-    deleteAccountById
+	getAccount,
+	getOrCreateAccount,
+	getAccountId,
+	createAccount,
+	deleteAccountByName,
+	deleteAccountById
 };
-

package/src/saas/internal-api/accounts/api/openapi/accounts.openapi.api.js

@@ -1,48 +1,48 @@
-const requests = require('../../../common/requests');
+const requests = require('../../../../../common/requests/cookieAuth/requests');
 const { backendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
-    createApiKey: `${backendUrl}/saas/api-keys`,
-    getStaticApiKeyByAccountId: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
-    getApiKeyByKeyValue: `${backendUrl}/saas/api-keys`,
-    removeStaticApiKey: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
-    dynamicApiKey: accountId =>`${backendUrl}/saas/accounts/${accountId}/dynamic-api-key`
+	createApiKey: `${backendUrl}/saas/api-keys`,
+	getStaticApiKeyByAccountId: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
+	getApiKeyByKeyValue: `${backendUrl}/saas/api-keys`,
+	removeStaticApiKey: accountId => `${backendUrl}/saas/accounts/${accountId}/static-api-keys`,
+	dynamicApiKey: accountId => `${backendUrl}/saas/accounts/${accountId}/dynamic-api-key`
 };
 
-const createStaticApiKey = async (data, context) => {
-    return requests.postRequestHandler(Endpoints.createApiKey, data, context).then(res => res.data);
+const createStaticApiKey = (data, context) => {
+	return requests.postRequestHandler(Endpoints.createApiKey, data, context);
 };
 
-const createGeneratorApiKey = async (data, context) => {
-    return requests.postRequestHandler(Endpoints.createApiKey, data, context).then(res => res.data);
+const createGeneratorApiKey = (data, context) => {
+	return requests.postRequestHandler(Endpoints.createApiKey, data, context);
 };
 
-const getStaticApiKeyByAccountId = async (accountId, context) => {
-    return requests.getRequestHandler(Endpoints.getStaticApiKeyByAccountId(accountId), {}, context).then(res => res.data);
+const getStaticApiKeyByAccountId = (accountId, context) => {
+	return requests.getRequestHandler(Endpoints.getStaticApiKeyByAccountId(accountId), {}, context);
 };
 
-const getApiKeyDetails = async (apiKeyValue, context) => {
-    return requests.getRequestHandler(Endpoints.getApiKeyByKeyValue, { apiKeyValue }, context).then(res => res.data);
+const getApiKeyDetails = (apiKeyValue, context) => {
+	return requests.getRequestHandler(Endpoints.getApiKeyByKeyValue, { apiKeyValue }, context);
 };
 
-const deleteStaticApiKey = async (accountId, context) => {
-    return requests.deleteRequestHandler(Endpoints.removeStaticApiKey(accountId), context).then(res=>res.data);
+const deleteStaticApiKey = (accountId, context) => {
+	return requests.deleteRequestHandler(Endpoints.removeStaticApiKey(accountId), context);
 };
 
-const deleteDynamicApiKey = async (accountId, context) => {
-    return requests.deleteRequestHandler(Endpoints.dynamicApiKey(accountId), context).then(res => res.data);
+const deleteDynamicApiKey = (accountId, context) => {
+	return requests.deleteRequestHandler(Endpoints.dynamicApiKey(accountId), context);
 };
 
-const makeDynamicApiKeyExpired = async (accountId, context) => {
-    return requests.patchRequestHandler(Endpoints.dynamicApiKey(accountId), context, {}).then(res => res.data);
+const makeDynamicApiKeyExpired = (accountId, context) => {
+	return requests.patchRequestHandler(Endpoints.dynamicApiKey(accountId), context, {});
 };
 
 module.exports = {
-    createStaticApiKey,
-    createGeneratorApiKey,
-    getStaticApiKeyByAccountId,
-    getApiKeyDetails,
-    makeDynamicApiKeyExpired,
-    deleteStaticApiKey,
-    deleteDynamicApiKey
+	createStaticApiKey,
+	createGeneratorApiKey,
+	getStaticApiKeyByAccountId,
+	getApiKeyDetails,
+	makeDynamicApiKeyExpired,
+	deleteStaticApiKey,
+	deleteDynamicApiKey
 };

package/src/saas/internal-api/accounts/api/openapi/accounts.openapi.setup.js

@@ -2,73 +2,73 @@ const accountsAPI = require('./accounts.openapi.api');
 const crypto = require('crypto');
 
 const generateApiKeyValue = accountName => {
-    return crypto.createHash('sha256').update(accountName).digest('base64');
+	return crypto.createHash('sha256').update(accountName).digest('base64');
 };
 
 const createStaticApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'ACCOUNT_STATIC', apiKeyName = null } = {}) => {
-    const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
-    return accountsAPI.createStaticApiKey(data, context);
+	const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
+	return accountsAPI.createStaticApiKey(data, context);
 };
 
 const createGeneratorApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'GENERATOR', apiKeyName = null } = {}) => {
-    const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
-    return accountsAPI.createGeneratorApiKey(data, context);
+	const data = { accountId, apiKeyValue, apiKeyName, apiKeyType };
+	return accountsAPI.createGeneratorApiKey(data, context);
 };
 
 const getStaticApiKeyByAccountId = async (accountId, context) => {
-    return accountsAPI.getStaticApiKeyByAccountId(accountId, context);
+	return accountsAPI.getStaticApiKeyByAccountId(accountId, context);
 };
 
 const getApiKeyDetails = async (apiKeyValue, context) => {
-    return accountsAPI.getApiKeyDetails(apiKeyValue, context);
+	return accountsAPI.getApiKeyDetails(apiKeyValue, context);
 };
 
 const deleteStaticApiKey = async (accountId, context) => {
-    return accountsAPI.deleteStaticApiKey(accountId, context);
+	return accountsAPI.deleteStaticApiKey(accountId, context);
 };
 
 const getOrCreateStaticApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'ACCOUNT_STATIC', apiKeyName = null } = {}) => {
-    let existingApiKey = await getStaticApiKeyByAccountId(accountId, context);
+	let response = await getStaticApiKeyByAccountId(accountId, context);
 
-    if (existingApiKey.apiKeyValue) {
-        return existingApiKey;
-    }
+	if (response.data.apiKeyValue) {
+		return response.data;
+	}
 
-    existingApiKey = await getApiKeyDetails(apiKeyValue, context);
+	response = await getApiKeyDetails(apiKeyValue, context);
 
-    if (!existingApiKey.apiKeyValue) {
-        return createStaticApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
-    }
+	if (!response.data.apiKeyValue) {
+		response = await createStaticApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
+	}
 
-    return existingApiKey;
+	return response.data;
 };
 
 const getOrCreateGeneratorApiKey = async (accountId, apiKeyValue, context, { apiKeyType = 'GENERATOR', apiKeyName = null } = {}) => {
-    const existingApiKey = await getApiKeyDetails(apiKeyValue, context);
+	const existingApiKey = await getApiKeyDetails(apiKeyValue, context);
 
-    if (!existingApiKey.apiKeyValue) {
-        return createGeneratorApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
-    }
+	if (!existingApiKey.apiKeyValue) {
+		return createGeneratorApiKey(accountId, apiKeyValue, context, { apiKeyType, apiKeyName });
+	}
 
-    return existingApiKey;
+	return existingApiKey;
 };
 
-const deleteDynamicApiKey= async (accountId, context) => {
-    return accountsAPI.deleteDynamicApiKey(accountId, context);
+const deleteDynamicApiKey = async (accountId, context) => {
+	return accountsAPI.deleteDynamicApiKey(accountId, context);
 };
 
-const makeDynamicApiKeyExpired= async (accountId, context) => {
-    return accountsAPI.makeDynamicApiKeyExpired(accountId, context);
+const makeDynamicApiKeyExpired = async (accountId, context) => {
+	return accountsAPI.makeDynamicApiKeyExpired(accountId, context);
 };
 
 module.exports = {
-    createStaticApiKey,
-    generateApiKeyValue,
-    getOrCreateStaticApiKey,
-    getOrCreateGeneratorApiKey,
-    getStaticApiKeyByAccountId,
-    getApiKeyDetails,
-    makeDynamicApiKeyExpired,
-    deleteStaticApiKey,
-    deleteDynamicApiKey
+	createStaticApiKey,
+	generateApiKeyValue,
+	getOrCreateStaticApiKey,
+	getOrCreateGeneratorApiKey,
+	getStaticApiKeyByAccountId,
+	getApiKeyDetails,
+	makeDynamicApiKeyExpired,
+	deleteStaticApiKey,
+	deleteDynamicApiKey
 };

package/src/saas/internal-api/accounts/api/settings/settings.api.js

@@ -1,21 +1,21 @@
-const requests = require('../../../common/requests');
+const requests = require('../../../../../common/requests/cookieAuth/requests');
 const { backendUrl } = require('../../../../../env').getEnv();
 
 const Endpoints = {
-    get: accountId => `${backendUrl}/saas/account/${accountId}/settings`,
-    edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
+	get: accountId => `${backendUrl}/saas/account/${accountId}/settings`,
+	edit: accountId => `${backendUrl}/saas/account/${accountId}/settings`
 };
 
 const getAccountSettings = async (accountId, context) => {
-    return requests.getRequestHandler(Endpoints.get(accountId), {}, context);
+	return requests.getRequestHandler(Endpoints.get(accountId), {}, context);
 };
 
 const updateAccountSettings = async (updateAccountSettingsModel, context) => {
-    const { accountId } = updateAccountSettingsModel;
-    return requests.putRequestHandler(Endpoints.edit(accountId), updateAccountSettingsModel, context);
+	const { accountId } = updateAccountSettingsModel;
+	return requests.putRequestHandler(Endpoints.edit(accountId), updateAccountSettingsModel, context);
 };
 
 module.exports = {
-    getAccountSettings,
-    updateAccountSettings
+	getAccountSettings,
+	updateAccountSettings
 };

package/src/saas/internal-api/accounts/api/settings/settings.setup.js

@@ -3,21 +3,21 @@ const { validateType } = require('../../../../../common/validations/typeValidati
 const UpdateAccountSettingsModel = require('../../models/settings/update.settings.model');
 
 const getAccountSettings = async (accountId, context) => {
-    return accountsAPI.getAccountSettings(accountId, context).then(res => res.data);
+	return accountsAPI.getAccountSettings(accountId, context).then(res => res.data);
 };
 
 const updateAccountSettings = async (updateAccountSettingsModel, context) => {
-    validateType(updateAccountSettingsModel, UpdateAccountSettingsModel);
-    return accountsAPI.updateAccountSettings(updateAccountSettingsModel, context);
+	validateType(updateAccountSettingsModel, UpdateAccountSettingsModel);
+	return accountsAPI.updateAccountSettings(updateAccountSettingsModel, context);
 };
 
 const restoreAccountSettings = async (accountId, context) => {
-    const updateAccountSettingsModel = new UpdateAccountSettingsModel(accountId, false, false , false);
-    return accountsAPI.updateAccountSettings(updateAccountSettingsModel, context);
+	const updateAccountSettingsModel = new UpdateAccountSettingsModel(accountId, false, false, false);
+	return accountsAPI.updateAccountSettings(updateAccountSettingsModel, context);
 };
 
 module.exports = {
-    getAccountSettings,
-    updateAccountSettings,
-    restoreAccountSettings
-};
+	getAccountSettings,
+	updateAccountSettings,
+	restoreAccountSettings
+};

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

@@ -11,9 +11,9 @@ const openApiServices = require('./api/openapi/accounts.openapi.setup');
 const settingsServices = require('./api/settings/settings.setup');
 
 const services = {
-    core: coreService,
-    openApi: openApiServices,
-    settings: settingsServices
+	core: coreService,
+	openApi: openApiServices,
+	settings: settingsServices
 };
 
-module.exports = { services, models };
+module.exports = { services, models };

package/src/saas/internal-api/accounts/models/core/create.account.model.js

@@ -3,14 +3,13 @@ const { credentials, accountCreationSecret } = env.getEnv();
 const PROPERTY_TYPE = 'Property Management';
 
 function CreateAccountModel(accountName, email, password = credentials.strongPassword,
-    secret = accountCreationSecret, propertyType = PROPERTY_TYPE) {
-
-    this.companyName = accountName;
-    this.email = email;
-    this.password = password;
-    this.verifyPassword = password;
-    this.secret = secret;
-    this.userType = propertyType;
+	secret = accountCreationSecret, propertyType = PROPERTY_TYPE) {
+	this.companyName = accountName;
+	this.email = email;
+	this.password = password;
+	this.verifyPassword = password;
+	this.secret = secret;
+	this.userType = propertyType;
 }
 
-module.exports = CreateAccountModel;
+module.exports = CreateAccountModel;