216 lines
9.1 KiB
JavaScript
216 lines
9.1 KiB
JavaScript
import * as mssqlArticle from '../../providers/mssql/queries/article.js';
|
|
import * as sqliteArticle from '../../providers/sqlite3/queries/article.js';
|
|
import { GET_CHILD_COUNT as MSSQL_GET_CHILD_COUNT } from '../../providers/mssql/queries/articleDelete.js';
|
|
import { GET_CHILD_COUNT as SQLITE_GET_CHILD_COUNT } from '../../providers/sqlite3/queries/articleDelete.js';
|
|
import * as mssqlAttrVal from '../../providers/mssql/queries/attributevalue.js';
|
|
import * as sqliteAttrVal from '../../providers/sqlite3/queries/attributevalue.js';
|
|
import * as mssqlArticleAttrVal from '../../providers/mssql/queries/articleattributevalue.js';
|
|
import * as sqliteArticleAttrVal from '../../providers/sqlite3/queries/articleattributevalue.js';
|
|
import { ADD as MSSQL_ADD_CATEGORYARTICLE } from '../../providers/mssql/queries/categoryarticle.js';
|
|
import { ADD as SQLITE_ADD_CATEGORYARTICLE } from '../../providers/sqlite3/queries/categoryarticle.js';
|
|
import { CREATE as MSSQL_CREATE_ARTICLETEXT } from '../../providers/mssql/queries/articletext.js';
|
|
import { CREATE as SQLITE_CREATE_ARTICLETEXT } from '../../providers/sqlite3/queries/articletext.js';
|
|
import { INSERT as MSSQL_INSERT_HISTORY } from '../../providers/mssql/queries/articlehistory.js';
|
|
import { INSERT as SQLITE_INSERT_HISTORY } from '../../providers/sqlite3/queries/articlehistory.js';
|
|
import resolveArticleBySku from './resolveArticleBySku.js';
|
|
import getBySku from './getBySku.js';
|
|
import makeRunner from '../runner.js';
|
|
import slugify from '../slugify.js';
|
|
|
|
export default function addChild(provider) {
|
|
const resolve = resolveArticleBySku(provider);
|
|
const load = getBySku(provider);
|
|
const isSqlite = provider?.dialect === 'sqlite3';
|
|
|
|
const queries = isSqlite ? sqliteArticle : mssqlArticle;
|
|
const getChildCountSql = isSqlite ? SQLITE_GET_CHILD_COUNT : MSSQL_GET_CHILD_COUNT;
|
|
const attrValQueries = isSqlite ? sqliteAttrVal : mssqlAttrVal;
|
|
const articleAttrValQueries = isSqlite ? sqliteArticleAttrVal : mssqlArticleAttrVal;
|
|
const addCategoryArticleSql = isSqlite ? SQLITE_ADD_CATEGORYARTICLE : MSSQL_ADD_CATEGORYARTICLE;
|
|
const createArticleTextSql = isSqlite ? SQLITE_CREATE_ARTICLETEXT : MSSQL_CREATE_ARTICLETEXT;
|
|
const insertHistorySql = isSqlite ? SQLITE_INSERT_HISTORY : MSSQL_INSERT_HISTORY;
|
|
|
|
/**
|
|
* Adds a child article to a father article.
|
|
*
|
|
* @param {number} googleAuthId - The id of the Google auth user.
|
|
* @param {string} fatherSku - The father article SKU.
|
|
* @param {object} options
|
|
* @param {number} [options.attributeValueId] - Existing attribute value ID for father's attribute.
|
|
* @param {string} [options.value] - String value to find or create under father's attribute.
|
|
* @param {string} [options.name] - Custom name for child article (defaults to father name + value).
|
|
* @param {number} [options.unitamount] - Optional unitamount override.
|
|
* @param {number} [options.weight] - Optional weight override.
|
|
* @param {boolean|number} [options.track_stock] - Optional track_stock override.
|
|
* @param {object} [tx] - Optional transaction.
|
|
* @returns {Promise<object>} The created child article detail.
|
|
*/
|
|
return async (googleAuthId, fatherSku, options = {}, tx) => {
|
|
const run = async (runner) => {
|
|
const { articleId: fatherId, companyId, languageId, companyuserId } = await resolve(
|
|
googleAuthId,
|
|
fatherSku,
|
|
runner,
|
|
);
|
|
|
|
// Fetch father article fields
|
|
const fatherRes = await runner.query(
|
|
'SELECT id, sku, company_id, unit_id, unitamount, weight, track_stock, brand_id, is_father, fatherarticle_id, fatherattributename_id FROM article WHERE id = @fatherId',
|
|
{ fatherId },
|
|
);
|
|
const father = fatherRes.rows[0];
|
|
if (!father) {
|
|
throw new Error('Father article not found');
|
|
}
|
|
if (!father.is_father || !father.fatherattributename_id) {
|
|
throw new Error('Article is not a father article');
|
|
}
|
|
|
|
// Fetch father's text / name
|
|
const fatherTextRes = await runner.query(
|
|
'SELECT name FROM articletext WHERE article_id = @fatherId AND language_id = @languageId',
|
|
{ fatherId, languageId },
|
|
);
|
|
const fatherName = fatherTextRes.rows[0]?.name || father.sku;
|
|
|
|
// Determine attribute value
|
|
let finalValueId = null;
|
|
let finalValue = null;
|
|
|
|
if (options.attributeValueId != null) {
|
|
if (typeof options.attributeValueId !== 'number' || !Number.isInteger(options.attributeValueId) || options.attributeValueId <= 0) {
|
|
throw new Error('Invalid attributeValueId');
|
|
}
|
|
const valRes = await runner.query(attrValQueries.GET_BY_ID_AND_COMPANY, {
|
|
id: options.attributeValueId,
|
|
companyId,
|
|
});
|
|
const row = valRes.rows[0];
|
|
if (!row || row.attributeId !== father.fatherattributename_id) {
|
|
throw new Error('Attribute value not found or does not match father attribute');
|
|
}
|
|
finalValueId = row.id;
|
|
finalValue = row.value;
|
|
} else if (typeof options.value === 'string' && options.value.trim()) {
|
|
const valStr = options.value.trim();
|
|
const existingValRes = await runner.query(attrValQueries.GET_BY_ATTRIBUTE_AND_VALUE, {
|
|
attributeId: father.fatherattributename_id,
|
|
value: valStr,
|
|
});
|
|
if (existingValRes.rows[0]) {
|
|
finalValueId = existingValRes.rows[0].id;
|
|
finalValue = existingValRes.rows[0].value;
|
|
} else {
|
|
const sortRes = await runner.query(attrValQueries.GET_NEXT_SORT, {
|
|
attributeId: father.fatherattributename_id,
|
|
});
|
|
const sort = sortRes.rows[0]?.sort ?? 0;
|
|
const createdValRes = await runner.query(attrValQueries.CREATE, {
|
|
attributeId: father.fatherattributename_id,
|
|
value: valStr,
|
|
sort,
|
|
});
|
|
finalValueId = createdValRes.rows[0]?.id ?? createdValRes.insertId;
|
|
finalValue = valStr;
|
|
}
|
|
} else {
|
|
throw new Error('Attribute value is required for child article');
|
|
}
|
|
|
|
// Compute child SKU: father.sku + '-' + finalValueId
|
|
const childSku = `${father.sku}-${finalValueId}`;
|
|
|
|
// Check if child SKU already exists
|
|
const existingChildRes = await runner.query(
|
|
'SELECT id FROM article WHERE sku = @childSku AND company_id = @companyId',
|
|
{ childSku, companyId },
|
|
);
|
|
if (existingChildRes.rows[0]) {
|
|
throw new Error(`Child article "${childSku}" already exists`);
|
|
}
|
|
|
|
// Next fathersort
|
|
const countRes = await runner.query(getChildCountSql, { articleId: fatherId });
|
|
const fathersort = countRes.rows[0]?.count ?? 0;
|
|
|
|
// Create child article
|
|
const rawTrack = options.track_stock ?? options.trackStock;
|
|
const finalTrackStock = rawTrack == null ? father.track_stock : (rawTrack ? 1 : 0);
|
|
|
|
const childRes = await runner.query(queries.CREATE_CHILD, {
|
|
companyId,
|
|
sku: childSku,
|
|
unitId: father.unit_id,
|
|
unitamount: options.unitamount ?? father.unitamount,
|
|
weight: options.weight ?? father.weight,
|
|
trackStock: finalTrackStock,
|
|
brandId: father.brand_id,
|
|
fatherArticleId: fatherId,
|
|
fathersort,
|
|
});
|
|
const childId = childRes.rows[0]?.id ?? childRes.insertId;
|
|
|
|
// Copy existing attribute values from father (ancestor attributes that father has)
|
|
const fatherAttrsRes = await runner.query(
|
|
'SELECT attributevalue_id, sort FROM articleattributevalue WHERE article_id = @fatherId',
|
|
{ fatherId },
|
|
);
|
|
for (const faRow of fatherAttrsRes.rows) {
|
|
if (faRow.attributevalue_id !== finalValueId) {
|
|
await runner.query(articleAttrValQueries.INSERT_ROW, {
|
|
articleId: childId,
|
|
attributeValueId: faRow.attributevalue_id,
|
|
sort: faRow.sort,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Link articleattributevalue
|
|
await runner.query(articleAttrValQueries.INSERT_ROW, {
|
|
articleId: childId,
|
|
attributeValueId: finalValueId,
|
|
sort: 0,
|
|
});
|
|
|
|
// Copy father's categories
|
|
const catRes = await runner.query(
|
|
'SELECT category_id FROM categoryarticle WHERE article_id = @fatherId',
|
|
{ fatherId },
|
|
);
|
|
for (const catRow of catRes.rows) {
|
|
await runner.query(addCategoryArticleSql, {
|
|
categoryId: catRow.category_id,
|
|
articleId: childId,
|
|
});
|
|
}
|
|
|
|
// Create article text
|
|
const childName = options.name?.trim() || `${fatherName} - ${finalValue}`;
|
|
const childSlug = slugify(childName);
|
|
await runner.query(createArticleTextSql, {
|
|
articleId: childId,
|
|
languageId,
|
|
name: childName,
|
|
slug: childSlug,
|
|
});
|
|
|
|
// History
|
|
await runner.query(insertHistorySql, {
|
|
articleId: childId,
|
|
companyuserId,
|
|
text: `Artikel "${childName}" (${childSku}) als Variante von "${father.sku}" angelegt`,
|
|
});
|
|
|
|
return load(googleAuthId, childSku, runner);
|
|
};
|
|
|
|
if (tx) {
|
|
return run(makeRunner(provider, tx));
|
|
}
|
|
if (typeof provider?.transaction === 'function') {
|
|
return provider.transaction(run);
|
|
}
|
|
return run(makeRunner(provider));
|
|
};
|
|
}
|