mirror of
https://github.com/badlogic/heissepreise.git
synced 2024-07-04 22:35:48 +02:00
dd938ba7cd
Penny now has a subcategory that leads back to the all categories page. This triggered an infinite recursion which eventually goes OOM boom.
119 lines
4.1 KiB
JavaScript
119 lines
4.1 KiB
JavaScript
const fs = require("fs");
|
|
const path = require("path");
|
|
|
|
exports.mergeAndSaveCategories = (store, categories) => {
|
|
const mappingFile = path.join(__dirname, `${store}-categories.json`);
|
|
if (fs.existsSync(mappingFile)) {
|
|
const oldMapping = JSON.parse(fs.readFileSync(mappingFile));
|
|
const oldLookup = {};
|
|
for (const category of oldMapping) {
|
|
oldLookup[category.id] = category;
|
|
}
|
|
|
|
for (const category of categories) {
|
|
const oldCategory = oldLookup[category.id];
|
|
if (oldCategory == null) {
|
|
console.log(`Found new unmapped category for ${store}: ${category.id} - ${category.description}`);
|
|
} else {
|
|
category.code = oldCategory.code;
|
|
delete oldLookup[category.id];
|
|
}
|
|
}
|
|
|
|
if (Object.keys(oldLookup).length > 0) {
|
|
for (const key in oldLookup) {
|
|
const category = oldLookup[key];
|
|
console.log(`Found category absent in latest mapping for ${store}: ${category.id} - ${category.description}`);
|
|
categories.push(category);
|
|
}
|
|
}
|
|
}
|
|
fs.writeFileSync(mappingFile, JSON.stringify(categories, null, 2));
|
|
return categories;
|
|
};
|
|
|
|
exports.globalUnits = {
|
|
"stk.": { unit: "stk", factor: 1 },
|
|
blatt: { unit: "stk", factor: 1 },
|
|
paar: { unit: "stk", factor: 1 },
|
|
stk: { unit: "stk", factor: 1 },
|
|
st: { unit: "stk", factor: 1 },
|
|
teebeutel: { unit: "stk", factor: 1 },
|
|
tücher: { unit: "stk", factor: 1 },
|
|
rollen: { unit: "stk", factor: 1 },
|
|
tabs: { unit: "stk", factor: 1 },
|
|
stück: { unit: "stk", factor: 1 },
|
|
mm: { unit: "cm", factor: 0.1 },
|
|
cm: { unit: "cm", factor: 1 },
|
|
zentimeter: { unit: "cm", factor: 1 },
|
|
m: { unit: "cm", factor: 100 },
|
|
meter: { unit: "cm", factor: 100 },
|
|
g: { unit: "g", factor: 1 },
|
|
gr: { unit: "g", factor: 1 },
|
|
gramm: { unit: "g", factor: 1 },
|
|
dag: { unit: "g", factor: 10 },
|
|
kg: { unit: "g", factor: 1000 },
|
|
kilogramm: { unit: "g", factor: 1000 },
|
|
ml: { unit: "ml", factor: 1 },
|
|
milliliter: { unit: "ml", factor: 1 },
|
|
dl: { unit: "ml", factor: 10 },
|
|
cl: { unit: "ml", factor: 100 },
|
|
l: { unit: "ml", factor: 1000 },
|
|
lt: { unit: "ml", factor: 1000 },
|
|
liter: { unit: "ml", factor: 1000 },
|
|
wg: { unit: "wg", factor: 1 },
|
|
};
|
|
|
|
exports.convertUnit = function (item, units, store, fallback) {
|
|
if (typeof item.quantity == "string") item.quantity = parseFloat(item.quantity.replace(",", "."));
|
|
|
|
let unit = item.unit;
|
|
if (typeof unit === "string") unit = unit.toLowerCase();
|
|
|
|
const conv = unit in exports.globalUnits ? exports.globalUnits[unit] : units[unit];
|
|
if (conv === undefined) {
|
|
if (fallback) {
|
|
item.quantity = fallback.quantity;
|
|
item.unit = fallback.unit;
|
|
} else {
|
|
console.error(`Unknown unit in ${store}: '${unit}' in item ${item.name}`);
|
|
}
|
|
return item;
|
|
}
|
|
|
|
item.quantity = conv.factor * item.quantity;
|
|
item.unit = conv.unit;
|
|
return item;
|
|
};
|
|
|
|
exports.parseUnitAndQuantityAtEnd = function (name) {
|
|
let unit,
|
|
quantity = 1;
|
|
const nameTokens = name.trim().replaceAll("(", "").replaceAll(")", "").replaceAll(",", ".").split(" ");
|
|
const lastToken = nameTokens[nameTokens.length - 1];
|
|
const secondLastToken = nameTokens.length >= 2 ? nameTokens[nameTokens.length - 2] : null;
|
|
|
|
const token = parseFloat(lastToken) ? lastToken : secondLastToken + lastToken;
|
|
const regex = /^([0-9.x]+)(.*)$/;
|
|
const matches = token.match(regex);
|
|
if (matches) {
|
|
matches[1].split("x").forEach((q) => {
|
|
quantity = quantity * parseFloat(q);
|
|
});
|
|
unit = matches[2];
|
|
return [quantity, unit.toLowerCase()];
|
|
}
|
|
return [undefined, undefined];
|
|
};
|
|
|
|
exports.showHeap = () => {
|
|
setInterval(() => {
|
|
const mu = process.memoryUsage();
|
|
// # bytes / KB / MB / GB
|
|
const gbNow = mu["heapUsed"] / 1024 / 1024 / 1024;
|
|
const gbRounded = Math.round(gbNow * 100) / 100;
|
|
|
|
console.log(`Heap allocated ${gbRounded} GB`);
|
|
}, 5000);
|
|
};
|