251 lines
8.5 KiB
JavaScript
251 lines
8.5 KiB
JavaScript
import * as mssqlQueries from '../../providers/mssql/queries/optionslist.js';
|
|
import * as sqliteQueries from '../../providers/sqlite3/queries/optionslist.js';
|
|
import resolveArticleBySku from '../article/resolveArticleBySku.js';
|
|
import getOptionsByArticleSku from './getOptionsByArticleSku.js';
|
|
import {
|
|
recordOptionsListChangeHistory,
|
|
recordArticleHistory,
|
|
} from '../articlehistory/record.js';
|
|
import makeRunner from '../runner.js';
|
|
|
|
async function hasOptionslistCycle(runner, rootArticleId, candidateOptionId) {
|
|
const visited = new Set();
|
|
const queue = [candidateOptionId];
|
|
|
|
while (queue.length > 0) {
|
|
const currentId = queue.shift();
|
|
if (currentId === rootArticleId) {
|
|
return true;
|
|
}
|
|
if (visited.has(currentId)) continue;
|
|
visited.add(currentId);
|
|
|
|
const res = await runner.query(
|
|
`SELECT ola.article_id
|
|
FROM article a
|
|
INNER JOIN optionslistarticle ola ON ola.optionslist_id = a.optionslist_id
|
|
WHERE a.id = @currentId`,
|
|
{ currentId },
|
|
);
|
|
|
|
for (const row of res.rows) {
|
|
if (row.article_id === rootArticleId) {
|
|
return true;
|
|
}
|
|
if (!visited.has(row.article_id)) {
|
|
queue.push(row.article_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
export default function setOptionsByArticleSku(provider) {
|
|
const resolve = resolveArticleBySku(provider);
|
|
const getOptions = getOptionsByArticleSku(provider);
|
|
const isSqlite = provider?.dialect === 'sqlite3';
|
|
const queries = isSqlite ? sqliteQueries : mssqlQueries;
|
|
|
|
/**
|
|
* Sets or clears the options list for an article.
|
|
*
|
|
* @param {number} googleAuthId - The id of the Google auth user.
|
|
* @param {string} sku - The master article SKU.
|
|
* @param {Array<{articleId?: number, sku?: string, count?: number, sort?: number, mandated?: boolean}>} [options=[]] - Array of options items.
|
|
* @param {object} [tx] - Optional transaction.
|
|
* @returns {Promise<Array<{id: number, articleId: number, sku: string, name: string|null, count: number, sort: number, mandated: boolean}>>}
|
|
*/
|
|
return async (googleAuthId, sku, options = [], tx) => {
|
|
if (!Array.isArray(options)) {
|
|
throw new Error('Invalid options array');
|
|
}
|
|
|
|
const run = async (runner) => {
|
|
const { articleId, companyId, companyuserId } = await resolve(googleAuthId, sku, runner);
|
|
|
|
const artRes = await runner.query(
|
|
'SELECT id, is_parent, articlelist_id, optionslist_id FROM article WHERE id = @articleId',
|
|
{ articleId },
|
|
);
|
|
const article = artRes.rows[0];
|
|
if (!article) {
|
|
throw new Error('Article not found');
|
|
}
|
|
|
|
if (article.is_parent) {
|
|
throw new Error('A parent article cannot have options');
|
|
}
|
|
|
|
// If options is empty: clear optionslist
|
|
if (options.length === 0) {
|
|
if (article.optionslist_id != null) {
|
|
// Read old options for history before clearing
|
|
const oldOptRes = await runner.query(
|
|
`SELECT a.sku, at.name
|
|
FROM optionslistarticle ola
|
|
INNER JOIN article a ON a.id = ola.article_id
|
|
LEFT JOIN articletext at ON at.article_id = a.id
|
|
WHERE ola.optionslist_id = @optionslistId
|
|
ORDER BY ola.sort ASC, ola.id ASC`,
|
|
{ optionslistId: article.optionslist_id },
|
|
);
|
|
const oldOptNames = oldOptRes.rows.map((r) => r.name || r.sku);
|
|
|
|
await runner.query(queries.SET_ARTICLE_OPTIONSLIST_ID, {
|
|
articleId,
|
|
optionslistId: null,
|
|
});
|
|
await runner.query(queries.DELETE_OPTIONSLIST, {
|
|
id: article.optionslist_id,
|
|
});
|
|
|
|
if (oldOptNames.length) {
|
|
await recordArticleHistory(runner, {
|
|
articleId,
|
|
companyuserId,
|
|
text: `Optionsliste geleert (war: [${oldOptNames.join(', ')}])`,
|
|
type: 'optionslist_cleared',
|
|
});
|
|
}
|
|
}
|
|
return [];
|
|
}
|
|
|
|
// Validate options
|
|
const validated = [];
|
|
const seenArticleIds = new Set();
|
|
const seenSorts = new Set();
|
|
|
|
for (let i = 0; i < options.length; i++) {
|
|
const item = options[i];
|
|
if (!item || typeof item !== 'object') {
|
|
throw new Error(`Option at index ${i} must be an object`);
|
|
}
|
|
|
|
let itemArticleId = null;
|
|
|
|
if (item.articleId !== undefined && item.articleId !== null) {
|
|
if (
|
|
typeof item.articleId !== 'number' ||
|
|
!Number.isInteger(item.articleId) ||
|
|
item.articleId <= 0
|
|
) {
|
|
throw new Error(`Option at index ${i} must specify a valid articleId or sku`);
|
|
}
|
|
const res = await runner.query(
|
|
'SELECT id FROM article WHERE id = @itemArticleId AND company_id = @companyId',
|
|
{ itemArticleId: item.articleId, companyId },
|
|
);
|
|
if (!res.rows[0]) {
|
|
throw new Error(`Article not found for option: ${item.articleId}`);
|
|
}
|
|
itemArticleId = res.rows[0].id;
|
|
} else if (item.sku !== undefined && item.sku !== null) {
|
|
if (typeof item.sku !== 'string' || !item.sku.trim()) {
|
|
throw new Error(`Option at index ${i} must specify a valid articleId or sku`);
|
|
}
|
|
const itemSku = item.sku.trim();
|
|
const res = await runner.query(
|
|
'SELECT id FROM article WHERE sku = @itemSku AND company_id = @companyId',
|
|
{ itemSku, companyId },
|
|
);
|
|
if (!res.rows[0]) {
|
|
throw new Error(`Article not found for option: ${itemSku}`);
|
|
}
|
|
itemArticleId = res.rows[0].id;
|
|
} else {
|
|
throw new Error(`Option at index ${i} must specify a valid articleId or sku`);
|
|
}
|
|
|
|
if (itemArticleId === articleId || await hasOptionslistCycle(runner, articleId, itemArticleId)) {
|
|
throw new Error('An article cannot have itself as an option or form a circular reference in options');
|
|
}
|
|
|
|
if (seenArticleIds.has(itemArticleId)) {
|
|
throw new Error(`Duplicate article in options: ${itemArticleId}`);
|
|
}
|
|
seenArticleIds.add(itemArticleId);
|
|
|
|
const rawCount = item?.count === undefined ? 1 : item.count;
|
|
if (
|
|
typeof rawCount !== 'number' ||
|
|
!Number.isInteger(rawCount) ||
|
|
rawCount <= 0 ||
|
|
rawCount > 2147483647
|
|
) {
|
|
throw new Error(`Invalid count for options item at index ${i}: must be a positive integer`);
|
|
}
|
|
const count = rawCount;
|
|
|
|
if (item.sort !== undefined && item.sort !== null) {
|
|
if (typeof item.sort !== 'number' || !Number.isInteger(item.sort)) {
|
|
throw new Error(`Invalid sort for options item at index ${i}: must be an integer`);
|
|
}
|
|
}
|
|
let sort = (typeof item?.sort === 'number' && Number.isInteger(item.sort)) ? item.sort : i;
|
|
|
|
while (seenSorts.has(sort)) {
|
|
sort++;
|
|
}
|
|
seenSorts.add(sort);
|
|
|
|
if (item.mandated !== undefined && item.mandated !== null && typeof item.mandated !== 'boolean') {
|
|
throw new Error(`Invalid mandated for options item at index ${i}: must be a boolean`);
|
|
}
|
|
const mandated = Boolean(item?.mandated);
|
|
|
|
validated.push({
|
|
articleId: itemArticleId,
|
|
count,
|
|
sort,
|
|
mandated,
|
|
});
|
|
}
|
|
|
|
let targetListId = article.optionslist_id;
|
|
if (targetListId == null) {
|
|
const listRes = await runner.query(queries.CREATE_OPTIONSLIST);
|
|
targetListId = listRes.rows[0]?.id ?? listRes.insertId;
|
|
await runner.query(queries.SET_ARTICLE_OPTIONSLIST_ID, {
|
|
articleId,
|
|
optionslistId: targetListId,
|
|
});
|
|
} else {
|
|
await runner.query(queries.DELETE_OPTIONSLIST_ARTICLES, {
|
|
optionslistId: targetListId,
|
|
});
|
|
}
|
|
|
|
for (const val of validated) {
|
|
await runner.query(queries.INSERT_OPTIONSLIST_ARTICLE, {
|
|
optionslistId: targetListId,
|
|
articleId: val.articleId,
|
|
count: val.count,
|
|
sort: val.sort,
|
|
mandated: val.mandated ? 1 : 0,
|
|
});
|
|
}
|
|
|
|
const result = await getOptions(googleAuthId, sku, runner);
|
|
|
|
// Write history for options list change
|
|
await recordOptionsListChangeHistory(runner, {
|
|
articleId,
|
|
companyuserId,
|
|
options: result,
|
|
});
|
|
|
|
return result;
|
|
};
|
|
|
|
if (tx) {
|
|
return run(makeRunner(provider, tx));
|
|
}
|
|
if (typeof provider?.transaction === 'function') {
|
|
return provider.transaction(run);
|
|
}
|
|
return run(makeRunner(provider));
|
|
};
|
|
}
|