guillermo/floriday
guillermo
/
floriday
1
1
Fork 0
Code Issues Pull Requests Releases Activity

fix eConnReset crashing the service

This commit is contained in:
Pau 2023-01-24 13:51:44 +01:00
parent 6c8230d1a0
commit c0f1575a85
2 changed files with 177 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
index.js
View File

@ -9,6 +9,12 @@ import { models } from './models/index.js';
import suppliers from './suppliersGln.js';
console.log = function () {
let args = Array.prototype.slice.call(arguments);
args.unshift(new moment().format('HH:mm:ss') + ' -');
console.info.apply(console, args);
};
let tokenExpirationDate = await vnUtils.getClientToken(models);
try {
@ -43,16 +49,20 @@ try {
// eslint-disable-next-line no-constant-condition
while (true) {
console.log('Querying the API to check for new data...');
console.log('Current token expiration date: ', tokenExpirationDate);
try{
console.log('Querying the API to check for new data...');
console.log('Current token expiration date: ', tokenExpirationDate);
await vnUtils.getStock();
await vnUtils.getStock();
if (moment().isAfter(tokenExpirationDate)) {
console.log('Token expired, getting a new one...');
tokenExpirationDate = await vnUtils.getClientToken(models);
if (moment().isAfter(tokenExpirationDate)) {
console.log('Token expired, getting a new one...');
tokenExpirationDate = await vnUtils.getClientToken(models);
}
} catch (error) {
console.error(error);
}
if (process.env.STATUS == 'development') {
await vnUtils.sleep(15000);
} else {
@ -62,10 +72,4 @@ try {
} catch (error) {
console.error('Unable to connect to the database:', error);
}
console.log = function () {
let args = Array.prototype.slice.call(arguments);
args.unshift(new moment().format('HH:mm:ss') + ' -');
console.info.apply(console, args);
};
}

177
utils.js
View File

@ -169,7 +169,7 @@ async function asyncQueue(fnArray, concurrency = 1) {
}
await Promise.all(promises); // 5
return results;
}
@ -349,6 +349,128 @@ async function getTradeitems(organizationGln) {
}
}
/**
* Gets a single tradeitem from the API and inserts it into the database
*
* @param {*} tradeItemId
*/
async function getTradeItem(tradeItemId) {
try {
const headers = {
'Content-Type': 'application/json',
'Authorization': `Bearer ${await getJWT()}`,
'X-Api-Key': process.env.API_KEY,
};
const tradeitemUrl = `${BASE_CUSTOMER_URL}trade-items/${tradeItemId}`;
const tradeitemRequest = await fetch(tradeitemUrl, {
method: 'GET',
headers: headers,
});
const tradeitemResponse = await tradeitemRequest.json();
tradeitemResponse.tradeItemId = await vnUuid(tradeitemResponse.tradeItemId);
await models.tradeItem.upsert({
tradeItemId: tradeitemResponse.tradeItemId,
supplierOrganizationId: tradeitemResponse.supplierOrganizationGln,
supplierOrganizationUuid: await vnUuid(tradeitemResponse.supplierOrganizationId),
code: tradeitemResponse.code,
gtin: tradeitemResponse.gtin,
vbnProductCode: tradeitemResponse.vbnProductCode,
name: tradeitemResponse.name,
isDeleted: tradeitemResponse.isDeleted,
sequenceNumber: tradeitemResponse.sequenceNumber,
tradeItemVersion: tradeitemResponse.tradeItemVersion,
isCustomerSpecific: tradeitemResponse.isCustomerSpecific,
isHiddenInCatalog: tradeitemResponse.isHiddenInCatalog,
});
await tradeitemResponse.characteristics.forEach((characteristic) => {
models.characteristics.upsert({
tradeItemFk: tradeitemResponse.tradeItemId,
vbnCode: characteristic.vbnCode,
vbnValueCode: characteristic.vbnValueCode,
});
});
await tradeitemResponse.seasonalPeriods.forEach((seasonalPeriod) => {
models.seasonalPeriod.upsert({
tradeItemFk: tradeitemResponse.tradeItemId,
startWeek: seasonalPeriod.startWeek,
endWeek: seasonalPeriod.endWeek,
});
});
await tradeitemResponse.photos.forEach(async (photo) => {
photo.id = await vnUuid(photo.id);
models.photos.upsert({
tradeItemFk: tradeitemResponse.tradeItemId,
photoId: photo.id,
url: photo.url,
seasonalPeriodFk: JSON.stringify(photo.seasonalPeriod),
type: photo.type,
primary: photo.primary,
});
});
await tradeitemResponse.packingConfigurations.forEach(async (packagingConfiguration) => {
let uuid = uuidv4();
uuid = await vnUuid(uuid);
await models.packingConfigurations.upsert({
tradeItemFk: tradeitemResponse.tradeItemId,
packingConfigurationId: uuid,
piecesPerPackage: packagingConfiguration.piecesPerPackage,
bunchesPerPackage: packagingConfiguration.bunchesPerPackage,
photoUrl: packagingConfiguration.photoUrl,
packagesPerLayer: packagingConfiguration.packagesPerLayer,
layersPerLoadCarrier: packagingConfiguration.layersPerLoadCarrier,
transportHeightInCm: packagingConfiguration.transportHeightInCm,
loadCarrierType: packagingConfiguration.loadCarrierType,
isPrimary: packagingConfiguration.isPrimary,
additionalPricePerPiece: JSON.stringify(packagingConfiguration.additionalPricePerPiece),
});
await models.package.upsert({
packingConfigurationsId: uuid,
vbnPackageCode: packagingConfiguration.package.vbnPackageCode,
vbnPackageValueCode: packagingConfiguration.package.vbnPackageValueCode,
});
});
await tradeitemResponse.botanicalNames.forEach((botanicalName) => {
models.botanicalNames.upsert({
tradeItemFk: tradeitemResponse.tradeItemId,
name: botanicalName,
});
});
await tradeitemResponse.countryOfOriginIsoCodes.forEach((countryOfOriginIsoCode) => {
models.countryOfOriginIsoCodes.upsert({
tradeItemFk: tradeitemResponse.tradeItemId,
isoCode: countryOfOriginIsoCode,
});
});
return true;
} catch (error) {
console.log('There was an error while saving the data to the database, trying again in 5 seconds...');
console.log(error.message);
await sleep(5000);
await getTradeItem(tradeItemId);
}
}
async function getStock() {
const suppliers = await models.suppliers.findAll();
@ -360,7 +482,7 @@ async function getStock() {
});
await asyncQueue(supplierQueue);
}
async function getStockBySupplier(supplierId) {
@ -375,10 +497,17 @@ async function getStockBySupplier(supplierId) {
const stockUrl = `${BASE_CUSTOMER_URL}supply-lines?supplierOrganizationId=${supplierId}`;
const stockRequest = await fetch(stockUrl, {
method: 'GET',
headers: headers,
});
let stockRequest;
try {
stockRequest = await fetch(stockUrl, {
method: 'GET',
headers: headers,
});
} catch (error) {
console.log(error.message);
return;
}
const stockResponse = await stockRequest.json();
@ -387,18 +516,28 @@ async function getStockBySupplier(supplierId) {
}
try {
if (stockResponse.length > 0 && stockResponse != null) {
let bar = new cliProgress.SingleBar({}, cliProgress.Presets.shades_grey);
bar.start(stockResponse.length, 0);
await stockResponse.forEach(async supplyLine => {
bar.increment();
let alreadyExists = await models.supplyLines.findOne({
where: {
supplyLineId: supplyLine.supplyLineId,
}
});
if (alreadyExists) {
return;
}
try {
await models.supplyLines.upsert({
supplyLineId: supplyLine.supplyLineId,
status: supplyLine.status,
@ -424,15 +563,17 @@ async function getStockBySupplier(supplierId) {
price: supplyLine.volumePrices.price,
supplyLineFk: await vnUuid(supplyLine.supplyLineId),
});
} catch (error) {
} catch (error) {
if (error.name == 'SequelizeForeignKeyConstraintError') {
bar.stop();
console.log('Missing data for the tradeitem: ' + supplyLine.tradeItemId);
console.log('Trying to get the tradeitem data...');
await getTradeItem(supplyLine.tradeItemId);
return;
}
bar.stop();
return;
}
});
bar.stop();
}
@ -440,7 +581,7 @@ async function getStockBySupplier(supplierId) {
console.log('There was an error while saving the data to the database, trying again in 5 seconds...');
await sleep(5000);
await getStockBySupplier(supplierId);
}
}
}