floriday/utils.js

import moment from 'moment';
import fetch from 'node-fetch';
import { models } from './models/index.js';
import { v4 as uuidv4 } from 'uuid';
import chalk from 'chalk';
import ora from 'ora';
const env = process.env;

/**
 *  Gets the Access Token from the client config table
 * 
 * @param {sequelize.models} models 
 * @returns {Date} tokenExpirationDate formated as YYYY-MM-DD HH:mm:ss
 */
export async function requestToken() {
	let spinner;
	try {
		spinner = ora(`Requesting new token...`).start();

		if (!env.CLIENT_ID || !env.CLIENT_SECRET)
			throw new Error(`You haven't provided the credentials`)
	
		const clientConfigData = await models.clientConfig.findOne();
	
		let tokenExpirationDate;
		if (clientConfigData)
			tokenExpirationDate = clientConfigData.tokenExpiration;
	
		if (!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
			};
	
			const data = {
				grant_type: 'client_credentials',
				client_id: clientId,
				client_secret: clientSecret,
				scope: 'role:app catalog:read supply:read organization:read network:write network:read'
			};
	
			const body = Object.keys(data)
				.map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
				.join('&');
	
			const response = await fetch(env.API_ENDPOINT, {
				method: 'POST',
				headers: {
					'Content-Type': 'application/x-www-form-urlencoded',
				},
				body,
			});
	
			const responseData = await response.json();
	
			if (response.ok)
				spinner.succeed();
			else {
				spinner.fail();
				criticalError(new Error(`Token request failed with status: ${response.status} - ${response.statusText}`));
			}
			let tokenExpirationDate = moment()
				.add(responseData.expires_in, 's')
				.format('YYYY-MM-DD HH:mm:ss');
	
			await updateClientConfig(
				clientId,
				clientSecret,
				responseData.access_token,
				tokenExpirationDate
			);
	
			return tokenExpirationDate;
		} else {
			spinner.text = 'Using stored token...'
			spinner.succeed();
			return tokenExpirationDate;
		}
	} catch (err) {
		spinner.fail();
		throw err;
	}
}

/**
 * Returns the current token
 * 
 * @returns {string}
 */
export async function getCurrentToken() {
	let data = await models.clientConfig.findOne();
	return data.currentToken
}
	
/**
 * Returns the expiration data of current token
 * 
 * @returns {string}
 */
export async function getCurrentTokenExpiration() {
	let data = await models.clientConfig.findOne();
	return data.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, accessToken, tokenExpirationDate) {
		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: clientId,
					clientSecret: clientSecret,
					currentToken: accessToken,
					tokenExpiration: tokenExpirationDate
				});
			spinner.succeed();
		} catch (error) {
			spinner.fail();
			console.log('There was a error while updating the client config');
			console.log(error);
		}
}

/**
 * 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;

}
// 1. Create an array of functions that will be executed in a queue
// 2. Create a function that will execute the functions in the queue
// 3. Create an array of promises that will execute the run function
// 4. Execute the run function while the concurrency is greater than 0
// 5. Return the results

/**
 * Syncs the sequence number for the given model
 * if no params are given it will reset all the sequence number to 0
 * 
 * @param {Number} current - current sequence number
 * @param {String} model - model name
 * @param {Number} maximumSequenceNumber - maximum sequence number
 * @returns
 */
export async function syncSequence(current = 0, model = null , maximumSequenceNumber = 0){
	if (model == null && current == 0){
		try {
			const spinner = ora(`Syncing sequence...`).start();
			let mockModels = [
				'suppliers',
				'tradeItems',
				'supplyLines',
			];
			let i = 1;
			for (let mockModel in mockModels) {
				spinner.text = `Syncing ${i++} sequences...`
				const element = mockModels[mockModel];
				await syncSequence(0, element);
			}
			spinner.succeed();
		} catch (err) {
			spinner.fail();
			throw new Error(err);
		}
	} else if (current) {
		let tx = await models.sequelize.transaction();
		try {
			let sequence = await models.sequenceNumber.findOrCreate({
				where: {
					model: model
				},
				defaults: {
					model: model,
					sequenceNumber: current,
					maximumSequenceNumber: maximumSequenceNumber
				},
				transaction: tx
			});

			if (sequence[1] == false){
				await models.sequenceNumber.update({
					sequenceNumber: current,
					maximumSequenceNumber: maximumSequenceNumber
				}, {
					where: {
						model: model
					},
					transaction: tx
				});
			}

			await tx.commit();

		} catch (error) {
			await tx.rollback();
			console.log(`Error while syncing sequence number for: ${model}: ${error}`);
		}
	}
}

export async function syncSuppliers(){
	let spinner = ora('Preparing to load suppliers...').start();
	try {
		let headers = {
			'Content-Type': 'application/json',
			'Authorization': `Bearer ${await getCurrentToken()}`,
			'X-Api-Key': process.env.API_KEY,
		};

		const response = await fetch(`${env.API_URL}/organizations/current-max-sequence`, {
			method: 'GET',
			headers,
		});

		if (!response.ok) {
			spinner.fail();
			criticalError(new Error(`Max sequence request failed with status: ${response.status} - ${response.statusText}`));
		}

		const maxSequenceNumber = await response.json();
		let timeFinish, timeToGoSec, timeToGoMin, timeLeft;
		for (let curSequenceNumber = 0; curSequenceNumber <= maxSequenceNumber; curSequenceNumber++) {
			let timeStart = new moment();

			let query = `${env.API_URL}/organizations/sync/${curSequenceNumber}?organizationType=SUPPLIER`;
			let response = await fetch(query, {
				method: 'GET',
				headers
			});
			let data = await response.json();

			let suppliers = 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})`
				await models.supplier.upsert({
					sequenceNumber: supplier.sequenceNumber,
					companyGln: supplier.companyGln,
					name: supplier.name ? supplier.name : null,
					commercialName: supplier.commercialName ? supplier.commercialName : null,
					email: supplier.email ? supplier.email : null,
					phone: supplier.phone ? supplier.phone : null,
					website: supplier.website ? supplier.website : null,
					organizationId: supplier.organizationId ? supplier.organizationId : null,
					rfhRelationId: supplier.rfhRelationId ? supplier.rfhRelationId : null,
					paymentProviders: supplier.paymentProviders.length ? `${supplier.paymentProviders}` : null,
					endDate: supplier.endDate ? supplier.endDate : null,
					mailingAddress: supplier.mailingAddress ? supplier.mailingAddress : null,
					physicalAddress: supplier.physicalAddress ? supplier.physicalAddress : null,
				});
			};
			await syncSequence(curSequenceNumber, 'suppliers', maxSequenceNumber);
			timeFinish = new moment();
			timeToGoSec = (timeFinish.diff(timeStart, 'seconds') * (maxSequenceNumber - curSequenceNumber) / 1000)
			timeToGoMin = Math.trunc(timeToGoSec / 60)
			if (!timeToGoMin)
				timeLeft = `${Math.trunc(timeToGoSec)} sec`
			else
				timeLeft = `${timeToGoMin} min`
		}
		spinner.text = `Syncing suppliers...`;
		spinner.succeed()
	}
	catch (err) {
		spinner.fail();
		throw new Error(err);
	}
}

export async function syncConn(){
	const spinner = ora(`Syncing connections...`).start();
	try {
		let connections = await models.connection.findAll();

		let headers = {
			'Content-Type': 'application/json',
			'Authorization': `Bearer ${await getCurrentToken()}`,
			'X-Api-Key': process.env.API_KEY
		};
	
		let remoteConnections = await fetch(`${env.API_URL}/connections`, {
			method: 'GET',
			headers
		});
	
		remoteConnections = await remoteConnections.json();
	
		let i = 1;
		for (let connection of connections){
			spinner.text = `Syncing ${i++} connections...`
			if (connection.isConnected == false)
				continue;
			let remoteConnection = remoteConnections.find(remoteConnection => remoteConnection == connection.organizationId);
	
			if (remoteConnection == undefined){
				console.log('Connection: ', connection, 'does not exist in the remote server');
				console.log('Creating remote connection');
				await fetch(`${env.API_URL}/connections/${connection.organizationId}`, {
					method: 'PUT',
					headers
				});
				await models.connection.update({ isConnected: true }, {
					where: {
						organizationId: connection.organizationId
					}
				});
				await models.supplier.update({ isConnected: true }, {
					where: {
						organizationId: connection.organizationId
					}
				});
			} else {
				await models.connection.update({ isConnected: true }, {
					where: {
						organizationId: connection.organizationId
					}
				});
				await models.supplier.update({ isConnected: true }, {
					where: {
						organizationId: connection.organizationId
					}
				});
			}
		}
		spinner.succeed();
	} catch (err) {
		spinner.fail();
		throw new Error(err);
	}
}

export async function syncTradeItems(){
	const spinner = ora(`Syncing trade items...`).start();
	const suppliers = await models.supplier.findAll();
	let i = 1;
	let x = 1;
	for (let supplier of suppliers) {
		if (!supplier.isConnected) continue;

		let query = `${env.API_URL}/trade-items?supplierOrganizationId=${supplier.organizationId}`;
		let headers = {
			'Content-Type': 'application/json',
			'Authorization': `Bearer ${await getCurrentToken()}`,
			'X-Api-Key': process.env.API_KEY
		};
		try {
			let request = await fetch(query, {
				method: 'GET',
				headers
			});

			let tradeItems = await request.json();

			if (!tradeItems.length)
				continue;

			for (let tradeItem of tradeItems) {
				await insertItem(tradeItem, supplier);
				spinner.text = `Syncing ${x++} suppliers`
			};

			console.log('Synced trade items for: ', supplier.commercialName);
			console.log('Remaining suppliers: ', suppliers.length - i++, 'of', suppliers.length);
			console.log('Total trade items: ', tradeItems.length);
		} catch (error) {
			spinner.fail();
			console.log('Error while syncing trade items for: ', supplier.commercialName);
			console.log(error);
		}
	}
	spinner.succeed()
}

/**
 *  Syncs the supply lines for suppliers that are connected
 *  to do this, it fetches all the supply lines for every tradeitem of the suppliers
 */
export async function syncSupplyLines(){
	try {
		let currentSequenceNumber = await models.sequenceNumber.findOne({ // TODO: Mirar como manejar este error
			where: {
				model: 'supplyLines'
			}
		});
	
		const spinner = ora(`Syncing trade items...`).start();
		let suppliers = await models.supplier.findAll({
			where: {
				isConnected: true
			}
		});
	
		let tradeItems = await models.tradeItem.findAll({
			where: {
				supplierOrganizationId: suppliers.map(supplier => supplier.organizationId)
			}
		});

		let promises = [];

		let headers = {
			'Content-Type': 'application/json',
			'Authorization': `Bearer ${await getCurrentToken()}`,
			'X-Api-Key': process.env.API_KEY
		};
		
		// Launch a promise for each supplier
		for (let tradeItem of tradeItems) {          
			let supplier = suppliers.find(supplier => supplier.organizationId == tradeItem.supplierOrganizationId);
			// eslint-disable-next-line no-async-promise-executor
			let promise = new Promise(async (resolve) => {
				try {
					let url = `${env.API_URL}/supply-lines/sync/0`
					const params = new URLSearchParams({
						supplierOrganizationId: supplier.organizationId,
						tradeItemId: tradeItem.tradeItemId,
						postFilterSelectedTradeItems: false
					});
					let request = await fetch(`${url}?${params.toString()}`, {
						method: 'GET',
						headers
					});

					let supplyLines = await request.json();
	
					if (supplyLines.length == 0) {
						console.log('No supply lines for supplier: ', supplier.commercialName, ' - ' , tradeItem.name);
						resolve([]);
						return;
					}
	
					resolve(supplyLines);
	
				} catch (error) {
					console.log('Error while syncing supply lines for: ', supplier.commercialName, ' - ' , tradeItem.name);
					console.log(error);
					resolve([]);
				}
			});
	
			promises.push(promise);
		
		}
	
		let supplyLines = await Promise.all(promises);
		let maximumSequenceNumber;
	
		for (let supplyLine of supplyLines) {
			maximumSequenceNumber = supplyLine.maximumSequenceNumber;
			supplyLine = supplyLine.results;
			try {
				for (let line of supplyLine) {
	
					let tradeItem = await models.tradeItem.findOne({
						where: {
							tradeItemId: line.tradeItemId
						}
					});
		
					if (!tradeItem) {
						console.log('Trade item not found for supply line: ', line.supplyLineId);
						console.log('Requesting data for trade item id: ', line.tradeItemId);
					
						let urlTradeItem = `${env.API_URL}/trade-items?tradeItemIds=${line.tradeItemId}`;
	
						let queryTradeItem = await fetch(urlTradeItem, {
							method: 'GET',
							headers
						});
	
						let tradeItem = await queryTradeItem.json();
	
						if (tradeItem.length == 0) {
	
							console.log('Trade item not found for supply line: ', line.supplyLineId);
							console.log('Trade item id: ', line.tradeItemId);
							continue;
						}
	
						let supplier = await models.supplier.findOne({
							where: {
								organizationId: tradeItem[0].supplierOrganizationId
							}
						});
	
						await insertItem(tradeItem[0], supplier);
	
						tradeItem = await models.tradeItem.findOne({
							where: {
								tradeItemId: line.tradeItemId
							}
						});
	
						if (!tradeItem) {
							console.log('Trade item not found for supply line: ', line.supplyLineId);
							console.log('Trade item id: ', line.tradeItemId);
							continue;
						}
	
					}
	
					await models.supplyLine.upsert({
						supplyLineId: line.supplyLineId,
						status: line.status,
						supplierOrganizationId: line.supplierOrganizationId,
						pricePerPiece: line.pricePerPiece,
						numberOfPieces: line.numberOfPieces,
						deliveryPeriod: line.deliveryPeriod,
						orderPeriod: line.orderPeriod,
						wharehouseId: line.wharehouseId,
						sequenceNumber: line.sequenceNumber,
						type: line.type,
						isDeleted: line.isDeleted,
						salesUnit: line.salesUnit,
						agreementReferenceCode: line.agreementReference.code,
						agreementReferenceDescription: line.agreementReference.description,
						isLimited: line.isLimited,
						isCustomerSpecific: line.isCustomerSpecific,
						tradeItemFk: line.tradeItemId,
					});
	
	
				}
			} catch (err) {
				spinner.fail();
				console.log('Error while syncing supply lines - ' + supplyLine.results[0].tradeItemId);
				throw new Error(err);
			}
		}
		spinner.succeed();
		console.log('Found', suppliers.length, 'connected suppliers');
	
		await syncSequence(currentSequenceNumber,'supplyLines' ,maximumSequenceNumber);
	} catch (err) {
		throw new Error(err);
	}
}

export async function insertItem(tradeItem, supplier) {

	let tx = await models.sequelize.transaction();

	console.log('Syncing trade item: ', tradeItem.name);

	try {

		// Temporal connection to all suppliers that have trade items

		let currentSupp = await models.supplier.findOne({
			where: {
				organizationId: tradeItem.supplierOrganizationId
			}
		});

		currentSupp.isConnected = true;

		await currentSupp.save({transaction: tx});

		await models.connection.upsert({
			organizationId: tradeItem.supplierOrganizationId,
			connect: true,
		}, {transaction: tx});

		// ----- 

		await models.tradeItem.upsert({
			tradeItemId: tradeItem.tradeItemId,
			supplierOrganizationId: tradeItem.supplierOrganizationId,
			code: tradeItem.code,
			gtin: tradeItem.gtin,
			vbnProductCode: tradeItem.vbnProductCode,
			name: tradeItem.name,
			isDeleted: tradeItem.isDeleted,
			sequenceNumber: tradeItem.sequenceNumber,
			tradeItemVersion: tradeItem.tradeItemVersion,
			isCustomerSpecific: tradeItem.isCustomerSpecific,
			isHiddenInCatalog: tradeItem.isHiddenInCatalog,
		}, 
		{transaction: tx});

		let characteristics = tradeItem.characteristics;

		for (let characteristic of characteristics) {
			await models.characteristic.upsert({
				vbnCode: characteristic.vbnCode,
				vbnValueCode: characteristic.vbnValueCode,
				tradeItemFk: tradeItem.tradeItemId,
			}, {transaction: tx});
		}

		let seasonalPeriods = tradeItem.seasonalPeriods;

		for (let seasonalPeriod of seasonalPeriods) {
			await models.seasonalPeriod.upsert({
				startWeek: seasonalPeriod.startWeek,
				endWeek: seasonalPeriod.endWeek,
				tradeItemFk: tradeItem.tradeItemId,
			}, {transaction: tx});
		}

		let photos = tradeItem.photos;

		for (let photo of photos) {
			await models.photo.upsert({
				id: photo.id,
				url: photo.url,
				type: photo.type,
				primary: photo.primary,
				tradeItemFk: tradeItem.tradeItemId,
			}, {transaction: tx});
		}

		let packingConfigurations = tradeItem.packingConfigurations;

		for (let packingConfiguration of packingConfigurations) {

			let uuid = uuidv4();

			await models.packingConfiguration.upsert({
				packingConfigurationId: uuid,
				piecesPerPackage: packingConfiguration.piecesPerPackage,
				bunchesPerPackage: packingConfiguration.bunchesPerPackage,
				photoUrl: packingConfiguration.photoUrl,
				packagesPerLayer: packingConfiguration.packagesPerLayer,
				layersPerLoadCarrier: packingConfiguration.layersPerLoadCarrier,
				additionalPricePerPiece : JSON.stringify(packingConfiguration.additionalPricePerPiece),
				transportHeightInCm: packingConfiguration.transportHeightInCm,
				loadCarrierType: packingConfiguration.loadCarrierType,
				isPrimary: packingConfiguration.isPrimary,
				tradeItemFk: tradeItem.tradeItemId,
			}, {transaction: tx});
			await models.package.upsert({
				vbnPackageCode: packingConfiguration.package.vbnPackageCode,
				customPackageId: packingConfiguration.package.customPackageId,
				packingConfigurationFk: uuid,
			}, {transaction: tx});
		}

		let countryOfOriginIsoCodes = tradeItem.countryOfOriginIsoCodes;

		countryOfOriginIsoCodes ??= 0;

		for (let countryOfOriginIsoCode of countryOfOriginIsoCodes) {
			await models.countryOfOriginIsoCode.upsert({
				isoCode: countryOfOriginIsoCode,
				tradeItemFk: tradeItem.tradeItemId,
			}, {transaction: tx});
		}

		let botanicalNames = tradeItem.botanicalNames;
					
		for (let botanicalName of botanicalNames) {
			await models.botanicalName.upsert({
				name: botanicalName.name,
				tradeItemFk: tradeItem.tradeItemId,
			}, {transaction: tx});
		}

		await tx.commit();

	} catch (error) {
		await tx.rollback();
		console.log('Error while syncing trade items for: ', supplier.commercialName);
		console.log(error);
	}

}

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