floriday/utils.js

import { models } from './models/sequelize.js';
import { v4 as uuidv4 } from 'uuid';
import axios from 'axios';
import moment from 'moment';
import chalk from 'chalk';
import ora from 'ora';

const env = process.env;

/**
 * Gets the Access Token
 * 
 * @param {Boolean} isForce Force to request new token
 */
export async function requestToken(isForce = false) {
	let spinner = ora(`Requesting new token...`).start();
	try {
		const clientConfigData = await models.clientConfig.findOne();
	
		let tokenExpirationDate, token;
		if (clientConfigData) {
			token = clientConfigData.currentToken;
			tokenExpirationDate = clientConfigData.tokenExpiration;
		}

		if (isForce || !token || !tokenExpirationDate || moment().isAfter(tokenExpirationDate)) {
			let clientId, clientSecret
			if (JSON.parse(env.USE_SECRETS_DB)) {
				clientId = clientConfigData.clientId;
				clientSecret = clientConfigData.clientSecret;
			} else {
				clientId = env.CLIENT_ID
				clientSecret = env.CLIENT_SECRET
			};
	
			let data = {
				grant_type: 'client_credentials',
				client_id: clientId,
				client_secret: clientSecret,
				scope: 'role:app catalog:read supply:read organization:read network:write network:read'
			};

			data = Object.keys(data)
				.map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
				.join('&')

			const headers = { 'Content-Type': 'application/x-www-form-urlencoded' };

			const response = (await vnRequest('POST', env.API_ENDPOINT, data, headers)).data;

			if (response.statusText = 'OK')
				spinner.succeed();
			else {
				spinner.fail();
				criticalError(new Error(`Token request failed with status: ${response.status} - ${response.statusText}`));
			}
			let tokenExpirationDate = moment()
				.add(response.expires_in, 's')
				.format('YYYY-MM-DD HH:mm:ss');
	
			await updateClientConfig(
				clientId,
				clientSecret,
				response.access_token,
				tokenExpirationDate
			);
		} else
			spinner.succeed('Using stored token...');
	} catch (err) {
		spinner.fail();
		throw err;
	}
}

/**
 * Returns the current token
 * 
 * @returns {string}
 */
export async function getCurrentToken() {
	return (await models.clientConfig.findOne()).currentToken;
}

/**
 * Check the floriday data config
 */
export async function checkConfig() {
	const spinner = ora(`Checking config...`).start();

	const excludedEnvVars = ['VSCODE_GIT_ASKPASS_EXTRA_ARGS'];
	const requiredEnvVars = Object.keys(env);
	const filteredEnvVars = requiredEnvVars.filter(reqEnvVar => !excludedEnvVars.includes(reqEnvVar));

	for (const reqEnvVar of filteredEnvVars) {
		if (!process.env[reqEnvVar]) {
			spinner.fail();
			throw new Error(`You haven't provided the ${reqEnvVar} environment variable`);
		}
	}
	const clientConfigData = await models.clientConfig.findOne();
	if (!clientConfigData)
		await updateClientConfig(env.CLIENT_ID,	env.CLIENT_SECRET);

	spinner.succeed();
}
	
/**
 * Returns the expiration of current token
 * 
 * @returns {string}
 */
export async function getCurrentTokenExpiration() {
	return (await models.clientConfig.findOne()).tokenExpiration;
}

/**
 * Updates the access token in the client config table
 * 
 * @param {String} clientId 
 * @param {String} clientSecret 
 * @param {String} accessToken 
 * @param {String} tokenExpirationDate 
 */
export async function updateClientConfig(clientId, clientSecret, currentToken, tokenExpiration) {
		try {
			const spinner = ora(`Updating token...`).start();
			if (!JSON.parse(process.env.USE_SECRETS_DB))
				clientId = clientSecret = null

				await models.clientConfig.upsert({
					id: 1,
					clientId,
					clientSecret,
					currentToken,
					tokenExpiration,
				});
			spinner.succeed();
		} catch (err) {
			spinner.fail();
			throw(err);
		}
}

/**
 * pauses the execution of the script for the given amount of milliseconds
 * 
 * @param {integer} ms 
 * @returns A promise that resolves after ms milliseconds.
 */
export async function sleep(ms) {
	return new Promise((resolve) => {
		setTimeout(resolve, ms);
	});
}

/**
 * Recieves an array of functions and executes them in a queue with the given concurrency
 * 
 * @param {Array} fnArray 
 * @param {Number} concurrency 
 * @returns 
 */
export async function asyncQueue(fnArray, concurrency = 1) {

	const results = []; // 1

	const queue = fnArray.map((fn, index) => () => fn().then((result) => results[index] = result));

	const run = async () => { // 2
		const fn = queue.shift();
		if (fn) {
			await fn();
			await run();
		}
	};

	const promises = []; // 3
	while (concurrency--) { // 4
		promises.push(run());
	}

	await Promise.all(promises); // 5 

	return results;

}

/**
 * Sync the suppliers
 */
export async function syncSuppliers(){
	let spinner = ora('Preparing to load suppliers...').start();
	try {
		const maxSequenceNumber = (await vnRequest('GET', `${env.API_URL}/organizations/current-max-sequence`)).data;

		let timeFinish, timeToGoSec, timeToGoMin, timeLeft;
		for (let curSequenceNumber = 0; curSequenceNumber <= maxSequenceNumber; curSequenceNumber++) {
			let timeStart = new moment();
			let suppliers = (await vnRequest('GET', `${env.API_URL}/organizations/sync/${curSequenceNumber}?organizationType=SUPPLIER`)).data.results;
			for (let supplier of suppliers) {
				curSequenceNumber = supplier.sequenceNumber;
				spinner.text = `Syncing suppliers, ${maxSequenceNumber - curSequenceNumber} are missing`
				if (timeFinish)	spinner.text = spinner.text + ` (${timeLeft})`
				if (JSON.parse(env.APPLY_ORG_FILTER) && supplier.companyGln) // Filtro temporal para quitar los que parecen test
					await insertOrganization(supplier);
			};
			timeFinish = new moment();
			timeToGoSec = (timeFinish.diff(timeStart, 'seconds') * (maxSequenceNumber - curSequenceNumber) / 1000);
			timeToGoMin = Math.trunc(timeToGoSec / 60);
			(!timeToGoMin) ? timeLeft = `${Math.trunc(timeToGoSec)} sec` : timeLeft = `${timeToGoMin} min`;
		}
		spinner.text = `Syncing suppliers...`;
		spinner.succeed()
	}
	catch (err) {
		spinner.fail();
		throw new Error(err);
	}
}

/**
 * Create the connections in Floriday
 */
export async function syncConnections(){
	await deleteConnections();

	let spinner;
	try {
		let connectionsInDb = await models.supplyLine.findAll({
			include : {
				model: models.organization,
				where: {
					isConnected: true,
				}
			},
			attributes: ['organizationId'],
			group: ['organizationId'],
		});

		const connectionsInFloriday = (await vnRequest('GET', `${env.API_URL}/connections`)).data;

		let isExists = false, connectionsToPut = [];
		for (let connectionInDb of connectionsInDb) {
			for (let connectionInFloriday of connectionsInFloriday)
				if (connectionInFloriday == connectionInDb.organizationId) {
					isExists = true;
					break;
				}
			if (!isExists) connectionsToPut.push(connectionInDb.organizationId)
			isExists = false;
		}

		if (connectionsToPut.length) spinner = ora(`Creating connections in Floriday...`).start();

		let i = 1;
		for (let connection of connectionsToPut) {
			spinner.text = `Creating ${i++} of ${connectionsToPut.length} connections in Floriday...`
			await vnRequest('PUT', `${env.API_URL}/connections/${connection}`);
		}
		if (spinner) spinner.succeed();
	} catch (err) {
		if (spinner) spinner.fail();
		throw new Error(err);
	}
}

/**
 * Sync the trade items for organizations that are connected
 */
export async function syncTradeItems(){
	const spinner = ora(`Syncing trade items...`).start();
	const suppliers = await models.organization.findAll({
		attributes: ['organizationId'],
		where: { isConnected: true }
	});
	let i = 0, x = 0;
	for (let supplier of suppliers) {
		try {
			const params = new URLSearchParams({
				supplierOrganizationId: supplier.organizationId,
			}).toString();
			let tradeItems = (await vnRequest('GET', `${env.API_URL}/trade-items?${params}`)).data
			
			spinner.text = `Syncing ${i} trade items of [${x++}|${suppliers.length}] suppliers...`
			if (!tradeItems.length) continue;

			for (let tradeItem of tradeItems) {
				await insertItem(tradeItem);
				spinner.text = `Syncing ${i++} trade items of [${x}|${suppliers.length}] suppliers...`
			};
		} catch (err) {
			spinner.fail();
			throw err;
		}
	}
	spinner.succeed()
}

/**
 * Sync the supply lines for organizations that are connected
 * 
 * If necessary, create the item or the warehouse
 */
export async function syncSupplyLines() {
	const spinner = ora(`Syncing supply lines...`).start();
	try {
		let connectedSuppliers = await models.organization.findAll({
			attributes: ['organizationId'],
			where: { isConnected: true }
		});

		let i = 0, x = 1;
		for (let supplier of connectedSuppliers) {
			spinner.text = `Syncing ${i} supply lines of [${x++}|${connectedSuppliers.length}] suppliers...`
			const params = new URLSearchParams({
				supplierOrganizationId: supplier.organizationId,
			}).toString();
			let supplyLines = (await vnRequest('GET',`${env.API_URL}/supply-lines?${params}`)).data;
			if (!supplyLines.length) continue

			for (let supplyLine of supplyLines) {
				// Check if the warehouse exists, and if it doesn't, create it
				let warehouse = await models.warehouses.findOne({
					where: { warehouseId: supplyLine.warehouseId }
				});
				if (!warehouse) {
					let warehouse = (await vnRequest('GET', `${env.API_URL}/warehouses/${supplyLine.warehouseId}`)).data;

					// Check if the organization exists, and if it doesn't, create it
					let organization = await models.organization.findOne({
						where: { organizationId: warehouse.organizationId }
					});
					if (!organization) {
						let organization = (await vnRequest('GET', `${env.API_URL}/organizations/${warehouse.organizationId}`)).data;
						await insertOrganization(organization);
					}

					await insertWarehouse(warehouse);
				}

				// Check if the trade item exists, and if it doesn't, create it
				let tradeItem = await models.tradeItem.findOne({
					where: { tradeItemId: supplyLine.tradeItemId }
				});
				if (!tradeItem) {
					let tradeItem = (await vnRequest('GET', `${env.API_URL}/trade-items/${supplyLine.tradeItemId}`)).data;
					await insertItem(tradeItem);
				}

				spinner.text = `Syncing ${i++} supply lines of [${x}|${connectedSuppliers.length}] suppliers...`
				await models.supplyLine.upsert({
					...supplyLine,
					organizationId: supplyLine.supplierOrganizationId,
					pricePerPiece_currency: supplyLine.pricePerPiece?.currency ?? null,
					pricePerPiece_value: supplyLine.pricePerPiece?.value ?? null,
					deliveryPeriod_startDateTime: supplyLine.deliveryPeriod?.startDateTime ?? null,
					deliveryPeriod_endDateTime: supplyLine.deliveryPeriod?.endDateTime ?? null,
					orderPeriod_startDateTime: supplyLine.orderPeriod?.startDateTime ?? null,
					orderPeriod_endDateTime: supplyLine.orderPeriod?.endDateTime ?? null,
					agreementReference_code: supplyLine.agreementReference?.code ?? null,
					agreementReference_description: supplyLine.agreementReference?.description ?? null,
					lastSync: moment(),
				});

				for (let volumePrice of supplyLine.volumePrices)
					await models.volumePrices.upsert({
						...volumePrice,
						supplyLineId: supplyLine.supplyLineId,
					});
			}
		}
		spinner.succeed();
	}
	catch (err) {
		spinner.fail();
		throw err;
	}
}

/**
 * Insert trade item and dependences in db
 * 
 * @param {array} tradeItem 
 */
export async function insertItem(tradeItem) {
	let tx;
	try {
		tx = await models.sequelize.transaction();

		// Upsert trade item
		await models.tradeItem.upsert({
			...tradeItem,
			organizationId: tradeItem.supplierOrganizationId,
			lastSync: moment(),
		}, { transaction: tx });

		// Upsert characteristics
		if (tradeItem.characteristics)
			if (tradeItem.characteristics.length)
				for (const characteristic of tradeItem.characteristics) {
					await models.characteristic.upsert({
						...characteristic,
						tradeItemId: tradeItem.tradeItemId,
					}, { transaction: tx });
				}
		// Upsert seasonal periods
		if (tradeItem.seasonalPeriods)
			if (tradeItem.seasonalPeriods.length)
				for (const seasonalPeriod of tradeItem.seasonalPeriods) {
					await models.seasonalPeriod.upsert({
						...seasonalPeriod,
						tradeItemId: tradeItem.tradeItemId,
					}, { transaction: tx });
				}

		// Upsert photos
		if (tradeItem.photos)
			if (tradeItem.photos.length)
				for (const photo of tradeItem.photos) {
					await models.photo.upsert({
						...photo,
						tradeItemId: tradeItem.tradeItemId,
					}, { transaction: tx });
				}

		// Upsert packing configurations
		if (tradeItem.packingConfigurations)
			if (tradeItem.packingConfigurations.length)
				for (const packingConfiguration of tradeItem.packingConfigurations) {
					const uuid = uuidv4();

					await models.packingConfiguration.upsert({
						packingConfigurationId: uuid,
						...packingConfiguration,
						additionalPricePerPiece_currency: packingConfiguration.additionalPricePerPiece.currency,
						additionalPricePerPiece_value: packingConfiguration.additionalPricePerPiece.value,
						tradeItemId: tradeItem.tradeItemId,
					}, { transaction: tx });

					await models.package.upsert({
						...packingConfiguration.package,
						packingConfigurationId: uuid,
					}, { transaction: tx });
				}

		// Upsert country of origin ISO codes
		if (tradeItem.countryOfOriginIsoCodes)
			if (tradeItem.countryOfOriginIsoCodes.length)
				for (const isoCode of tradeItem.countryOfOriginIsoCodes || []) {
					await models.countryOfOriginIsoCode.upsert({
						isoCode,
						tradeItemId: tradeItem.tradeItemId,
					}, { transaction: tx });
				}

		// Upsert botanical names
		if (tradeItem.botanicalNames)
			if (tradeItem.botanicalNames.length)
				for (const botanicalName of tradeItem.botanicalNames) {
					await models.botanicalName.upsert({
						botanicalNameId: uuidv4(),
						name: botanicalName,
						tradeItemId: tradeItem.tradeItemId,
					}, { transaction: tx });
				}

		await tx.commit();
	} catch (err) {
		await tx.rollback();
		throw err;
	}
}

/**
 * Insert warehouse in db
 * 
 * @param {array} warehouse 
 */
export async function insertWarehouse(warehouse) {
	let tx;
	try {
		tx = await models.sequelize.transaction();
		await models.warehouses.upsert({
			...warehouse,
			location_gln: warehouse.location.gln,
			location_address_addressLine: warehouse.location.address.addressLine,
			location_address_city: warehouse.location.address.city,
			location_address_countryCode: warehouse.location.address.countryCode,
			location_address_postalCode: warehouse.location.address.postalCode,
			location_address_stateOrProvince: warehouse.location.address.stateOrProvince,
			lastSync: moment(),
		});
		await tx.commit();
	} catch (err) {
		await tx.rollback();
		throw err;
	}
}

/**
 * Insert organization in db
 * 
 * @param {array} organization 
 */
export async function insertOrganization(organization) {
	let tx;
	try {
		tx = await models.sequelize.transaction();
		await models.organization.upsert({
			...organization,
			isConnected: JSON.parse(env.SUPPLIERS_ALWAYS_CONN),
			lastSync: moment(),
		});
		await tx.commit();
	} catch (err) {
		await tx.rollback();
		throw err;
	}
}

/**
 * Sync the warehouses for organizations that are connected
 **/
export async function syncWarehouses(){
	let spinner = ora('Syncing warehouses...').start();
	try {
		const suppliers = await models.organization.findAll({
			where: { isConnected: true }
		});

		let x = 0, i = 0;
		for (let supplier of suppliers) {
			spinner.text = `Syncing ${i} warehouses of [${x++}|${suppliers.length}] suppliers...`
			const warehouses = (await vnRequest('GET', `${env.API_URL}/organizations/supplier/${supplier.organizationId}/warehouses`)).data;
			for (let warehouse of warehouses) {
				spinner.text = `Syncing ${i++} warehouses of [${x}|${suppliers.length}] suppliers...`
				await insertWarehouse(warehouse);
			}
		}
		spinner.succeed();
	}
	catch (err) {
		spinner.fail();
		throw new Error(err);
	}
}

/**
 * Removes Floriday connections that we don't have in the database
 **/
export async function deleteConnections() {
	let spinner;
	try {
		let i = 1;
		const connectionsInFloriday = (await vnRequest('GET', `${env.API_URL}/connections`)).data;
		const connectionsInDb = await models.organization.findAll({
			attributes: ['organizationId'],
			where: { isConnected: true }
		});

		let isExists = false, ghostConnections = [];
		for (let connectionInFloriday of connectionsInFloriday) {
			for (let connectionInDb of connectionsInDb)
				if (connectionInFloriday == connectionInDb.organizationId) {
					isExists = true;
					break;
				}
			if (!isExists) ghostConnections.push(connectionInFloriday)
			isExists = false;
		}

		if (ghostConnections.length)
			spinner = ora(`Deleting connections that aren't in the db...`).start();

		for (let connection of ghostConnections) {
			await vnRequest('DELETE', `${env.API_URL}/connections/${connection}`);
			spinner.text = `Deleting ${i++} of ${ghostConnections.length} that aren't in the db...`
		}
		if (spinner) spinner.succeed();
	} catch (err) {
		if (spinner) spinner.fail();
		criticalError(err);
	}
}

/**
 * Perform a REST request
 * 
 * @param {string} url 
 * @param {string} method 
 * @param {array} body 
 * @param {array} header 
 * 
 * @return {array}
 **/
export async function vnRequest(method, url, data, headers) {
	if (!headers)
		headers = {
			'Content-Type': 'application/json',
			'Authorization': `Bearer ${await getCurrentToken()}`,
			'X-Api-Key': process.env.API_KEY,
		};

	for(let i = 0; i < env.MAX_REQUEST_ATTEMPTS; i++) {
	  try {
		if (['GET', 'DELETE'].includes(method))
			return await axios({method, url, headers});
		else
			return await axios({method, url, data, headers});
	  } catch (err) {
		switch (err.code) {
			case 'ECONNRESET': // Client network socket TLS
			case 'EAI_AGAIN': // getaddrinfo
				warning(err);
				await sleep(1000);
				break;
			case 'ECONNABORTED':
			case 'ECONNREFUSED':
			case 'ERR_BAD_REQUEST':
				switch (err.response.status) {
					case 504:
					case 502:
						warning(err);
						await sleep(1000);
						break;
					case 429: // Too Many Requests
						warning(err);
						await sleep(3400); // Stipulated by Floriday
						break;
					case 401: // Unauthorized
						warning(err);
						await requestToken(true);
						headers.Authorization ?
							headers.Authorization = `Bearer ${await getCurrentToken()}` :
							criticalError(err);
						break;
					default:
						criticalError(err);
				}
				break;
			default:
				criticalError(err);
		}
	  }
	}
}

/**
 * Critical error
 * 
 * @param {err}
 **/
export async function criticalError(err) {
	console.log(chalk.red.bold(`[CRITICAL]`), chalk.red(`${err.message}`));
	process.exit();
}

/**
 * Warning
 * 
 * @param {err}
 **/
export async function warning(err) {
	console.log(chalk.yellow.bold(`[WARNING]`), chalk.yellow(`${err.message}`));
}