Files
core-prestashop/src/PrestaApi.js
T

318 lines
11 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
const { Core, Log } = require('@orbito/api-lib');
const js2xmlparser = require("js2xmlparser");
const NodeCache = require("node-cache");
module.exports = class PrestashopApi {
constructor(shopUrl, apiKey, legacy = true, requestOptions = {}) {
this.shopUrl = new URL(shopUrl);
this.apiKey = apiKey;
this.cache = new NodeCache({ stdTTL: 600, checkperiod: 100 });
this.legacy = legacy; // czy używać legacy API (dla PrestaShop < 8)
this.requestTimeoutMs = requestOptions.timeoutMs || 15000;
this.maxGetAttempts = requestOptions.maxGetAttempts || 3;
this.retryBaseMs = requestOptions.retryBaseMs || 250;
}
getUrl(endpoint = "") {
if (endpoint.startsWith('/')) {
endpoint = endpoint.slice(1);
}
if (this.shopUrl.pathname == '/') {
return this.shopUrl.origin + '/api/' + endpoint;
}
if (this.shopUrl.pathname.endsWith('api') || this.shopUrl.pathname.endsWith('api/')) {
return this.shopUrl.href.endsWith('/') ? this.shopUrl.href + endpoint : this.shopUrl.href + '/' + endpoint;
}
// pozostałe przypadki kiedy sklep znajduje sie w folderze np https://nanocor.eu/b2b
let href = this.shopUrl.href;
if (href.endsWith('/')) {
return href + 'api/' + endpoint;
} else {
return href + '/api/' + endpoint;
}
}
async makeRequest(endpoint, metod, data, allowPartialSuccess = false) {
// @todo przemyśleć czy nie dodac tutaj na sztywno do kazdego zapytania output_format=JSON
let url = this.getUrl(endpoint);
const method = String(metod || 'GET').toUpperCase();
let options = {
method,
headers: {
"Authorization": "Basic " + Buffer.from(this.apiKey + ":").toString("base64"),
'content-type': 'application/xml',
'accept': 'application/json'
}
};
if (data) {
if (method === 'GET') {
const params = new URLSearchParams(data);
url += (url.includes('?') ? '&' : '?') + params.toString();
} else {
options.body = js2xmlparser.parse("prestashop", data, {
format: {
doubleQuotes: true,
pretty: false
}
});
}
}
const maxAttempts = method === 'GET' ? this.maxGetAttempts : 1;
for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
try {
const response = await this.fetchWithTimeout(url, options);
const body = response.text();
let parsed = {};
if (body) {
try {
parsed = JSON.parse(body);
} catch (parseError) {
const error = new Error(`PrestaShop returned invalid JSON (HTTP ${response.status})`);
error.statusCode = response.status;
throw error;
}
}
if (response.status < 200 || response.status >= 300) {
if (allowPartialSuccess && response.status === 500 && parsed && typeof parsed === 'object' && Object.keys(parsed).length > 0) {
Log.warn('PrestaShop returned usable data with HTTP 500', { endpoint });
return parsed;
}
const error = new Error(`PrestaShop request failed with HTTP ${response.status}`);
error.statusCode = response.status;
error.responseBody = body.slice(0, 1000);
throw error;
}
return parsed;
} catch (error) {
const retryableStatus = [408, 425, 429].includes(error.statusCode) || error.statusCode >= 500;
const retryable = method === 'GET' && (retryableStatus || !error.statusCode);
if (!retryable || attempt >= maxAttempts) throw error;
await new Promise(resolve => setTimeout(resolve, this.retryBaseMs * (2 ** (attempt - 1))));
}
}
}
async fetchWithTimeout(url, options) {
let timer;
try {
return await Promise.race([
Core.fetch(url, options),
new Promise((_, reject) => {
timer = setTimeout(() => {
const error = new Error(`PrestaShop request timed out after ${this.requestTimeoutMs} ms`);
error.code = 'PRESTASHOP_TIMEOUT';
reject(error);
}, this.requestTimeoutMs);
timer.unref?.();
}),
]);
} finally {
clearTimeout(timer);
}
}
async isBLSupported() {
let cacheKey = "bl_supported";
let blSupported = this.cache.get(cacheKey);
if (typeof blSupported == 'undefined') {
try {
let res = await this.makeRequest('bl_order', 'GET', { limit: 1, output_format: "JSON" });
blSupported = res.orders && res.orders.length > 0;
} catch (e) {
blSupported = false;
}
this.cache.set(cacheKey, blSupported);
}
return blSupported;
}
async getCountry(countryId) {
let cacheKey = "country_" + countryId;
let country = this.cache.get(cacheKey);
if (!country) {
let res = await this.makeRequest('countries/' + countryId, 'GET', { output_format: "JSON" });
country = res.country;
this.cache.set(cacheKey, country);
}
return country;
}
async getCarrier(orderId) {
let cacheKey = "carrier_" + orderId;
let carrier = this.cache.get(cacheKey);
if (!carrier) {
let res = await this.makeRequest('carriers/' + orderId, 'GET', { output_format: "JSON" });
carrier = res.carrier;
this.cache.set(cacheKey, carrier);
}
return carrier;
}
async getCurrency(currencyId) {
let cacheKey = "currency_" + currencyId;
let currency = this.cache.get(cacheKey);
if (!currency) {
let res = await this.makeRequest('currencies/' + currencyId, 'GET', { output_format: "JSON" });
currency = res.currency;
this.cache.set(cacheKey, currency);
}
return currency;
}
async getProduct(productId) {
let cacheKey = "product_" + productId;
let product = this.cache.get(cacheKey);
if (!product) {
let res = await this.makeRequest('products/' + productId, 'GET', { output_format: "JSON" }, true);
if (res.product) {
product = res.product;
this.cache.set(cacheKey, product);
} else {
throw new Error("Product data not found in response");
}
}
return product;
}
async getProductCombination(combinationId) {
let cacheKey = "product_combination_" + combinationId;
let combination = this.cache.get(cacheKey);
if (!combination) {
let res = await this.makeRequest('combinations/' + combinationId, 'GET', { output_format: "JSON" });
combination = res.combination;
this.cache.set(cacheKey, combination);
}
return combination;
}
async getStatuses() {
let cacheKey = "statuses";
let statuses = this.cache.get(cacheKey);
if (!statuses) {
let res = await this.makeRequest('order_states', 'GET', { output_format: "JSON", display: '[id,name,color,deleted]' });
statuses = res.order_states;
this.cache.set(cacheKey, statuses);
}
return statuses;
}
async getOrder(orderId) {
const blSupported = await this.isBLSupported();
const endpoint = blSupported ? 'bl_order' : 'orders';
const res = await this.makeRequest(endpoint + '/' + orderId, 'GET', { output_format: 'JSON' });
return res?.order || null;
}
async getOrderPayments(orderReference) {
const res = await this.makeRequest('order_payments', 'GET', {
output_format: 'JSON',
display: 'full',
'filter[order_reference]': orderReference,
});
return res?.order_payments || [];
}
async setOrderState(orderId, stateId) {
if (this.legacy) {
return await this.updateOrderLegacy(orderId, {
current_state: stateId
});
}
return await this.updateOrder(orderId, {
current_state: stateId
});
}
async updateOrder(orderId, data) {
let res = await this.makeRequest('orders?output_format=JSON', 'PATCH', {
order: {
id: orderId,
...data
}
});
if (res && res.order && res.order.id) {
return res.order;
} else {
throw new Error("Failed to set order state");
}
}
async updateOrderLegacy(orderId, data) {
// in legacy API, we need to use PUT instead of PATCH
// and we need to sent the whole order data, not just the fields we want to update
// so we need to fetch the current order data first
let currentOrder = await this.makeRequest('orders/' + orderId + '?output_format=JSON', 'GET');
if (!currentOrder || !currentOrder.order || !currentOrder.order.id) {
throw new Error("Order not found");
}
// merge current order data with the new data
data = {
...currentOrder.order,
...data
};
let res = await this.makeRequest('orders/' + orderId + '?output_format=JSON', 'PUT', {
order: data
});
if (res && res.order && res.order.id) {
return res.order;
} else {
throw new Error("Failed to set order state");
}
}
// PrestaShop image type (not original). home_default ≈ 250×250 in classic theme.
static PRODUCT_IMAGE_TYPE = 'home_default';
getProductImageUrl(productId, imageId) {
const url = this.getUrl(
'images/products/' + productId + '/' + imageId + '/' + PrestashopApi.PRODUCT_IMAGE_TYPE
);
const sep = url.includes('?') ? '&' : '?';
return url + sep + 'ws_key=' + encodeURIComponent(this.apiKey);
}
async getProductCoverImageUrl(productId) {
const product = await this.getProduct(productId);
const defaultImageId = product.id_default_image;
if (defaultImageId && defaultImageId !== '0' && defaultImageId !== '') {
return this.getProductImageUrl(productId, defaultImageId);
}
if (product.associations?.images?.length > 0) {
return this.getProductImageUrl(productId, product.associations.images[0].id);
}
return null;
}
async getProductImageBuffer(productId, imageId) {
let r = await Request({
url: this.getUrl(
'images/products/' + productId + '/' + imageId + '/' + PrestashopApi.PRODUCT_IMAGE_TYPE
),
encoding: null,
headers : { "Authorization" : "Basic " + Buffer.from(this.apiKey + ":").toString("base64") }
});
return r;
}
};