689 lines
25 KiB
JavaScript
689 lines
25 KiB
JavaScript
const { pool } = require('../db');
|
|
|
|
const STATUS_LABELS = {
|
|
open: 'Em aberto',
|
|
in_progress: 'Em andamento',
|
|
finished: 'Finalizada',
|
|
canceled: 'Cancelada'
|
|
};
|
|
|
|
const normalizeStatus = (status) => {
|
|
const normalizedStatus = String(status || 'open').trim().toLowerCase();
|
|
if (['open', 'em_aberto', 'em aberto', 'aberta'].includes(normalizedStatus)) return 'open';
|
|
if (['in_progress', 'andamento', 'em andamento'].includes(normalizedStatus)) return 'in_progress';
|
|
if (['finished', 'finalizada', 'finalizado'].includes(normalizedStatus)) return 'finished';
|
|
if (['canceled', 'cancelada', 'cancelado', 'cancelled'].includes(normalizedStatus)) return 'canceled';
|
|
return normalizedStatus || 'open';
|
|
};
|
|
|
|
const normalizeDateParam = (value) => {
|
|
if (!value) return null;
|
|
const normalizedValue = String(value).trim();
|
|
const isoMatch = normalizedValue.match(/^(\d{4})[-/](\d{1,2})[-/](\d{1,2})/);
|
|
if (isoMatch) {
|
|
const [, year, month, day] = isoMatch;
|
|
const date = new Date(`${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}T00:00:00`);
|
|
return Number.isNaN(date.getTime()) ? null : `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`;
|
|
}
|
|
|
|
const brMatch = normalizedValue.match(/^(\d{1,2})[-/](\d{1,2})[-/](\d{4})/);
|
|
if (brMatch) {
|
|
const [, day, month, year] = brMatch;
|
|
const date = new Date(`${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}T00:00:00`);
|
|
return Number.isNaN(date.getTime()) ? null : `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`;
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
const formatDate = (value) => {
|
|
if (!value) return null;
|
|
if (value instanceof Date && !Number.isNaN(value.getTime())) {
|
|
return value.toISOString().slice(0, 10);
|
|
}
|
|
return String(value).slice(0, 10);
|
|
};
|
|
|
|
const normalizeText = (value) => String(value || '').trim();
|
|
|
|
const normalizeQuantity = (value) => {
|
|
const normalizedValue = typeof value === 'string' && value.includes(',')
|
|
? value.replace(/\./g, '').replace(',', '.')
|
|
: value;
|
|
const quantity = Number(normalizedValue);
|
|
if (!Number.isFinite(quantity) || quantity <= 0) return 0;
|
|
return quantity;
|
|
};
|
|
|
|
const normalizeNullableQuantity = (value) => {
|
|
const quantity = normalizeQuantity(value);
|
|
return quantity || null;
|
|
};
|
|
|
|
const normalizeInteger = (value) => {
|
|
const number = Number(value);
|
|
return Number.isInteger(number) ? number : null;
|
|
};
|
|
|
|
const mapComponent = (component) => ({
|
|
id: component.id,
|
|
componentTinyId: component.component_tiny_id || '',
|
|
componentSku: component.component_sku || '',
|
|
componentName: component.component_name || '',
|
|
quantityPerUnit: Number(component.quantity_per_unit || 0),
|
|
totalQuantity: Number(component.total_quantity || 0),
|
|
unit: component.unit || ''
|
|
});
|
|
|
|
const mapStep = (step) => ({
|
|
id: step.id,
|
|
stepNumber: step.step_number === null ? null : Number(step.step_number),
|
|
name: step.name || '',
|
|
startDate: formatDate(step.start_date),
|
|
endDate: formatDate(step.end_date),
|
|
status: step.status || '',
|
|
color: step.color || ''
|
|
});
|
|
|
|
const mapProductionOrderRow = (row) => {
|
|
const status = normalizeStatus(row.status);
|
|
|
|
return {
|
|
id: row.id,
|
|
tinyId: row.tiny_id || '',
|
|
number: row.number || '',
|
|
status,
|
|
statusLabel: STATUS_LABELS[status] || row.status || 'Em aberto',
|
|
orderReference: row.order_reference || '',
|
|
issueDate: formatDate(row.issue_date),
|
|
expectedDate: formatDate(row.expected_date),
|
|
productSku: row.product_sku || '',
|
|
productDescription: row.product_description || '',
|
|
quantity: Number(row.quantity || 0),
|
|
unit: row.unit || 'UN',
|
|
integrationStatus: row.integration_status || '',
|
|
notes: row.notes || '',
|
|
supplier: row.supplier || '',
|
|
lotCode: row.lot_code || '',
|
|
rollQuantity: row.roll_quantity === null ? null : Number(row.roll_quantity),
|
|
fabricKg: row.fabric_kg === null ? null : Number(row.fabric_kg),
|
|
ribKg: row.rib_kg === null ? null : Number(row.rib_kg),
|
|
yieldPiecesPerKg: row.yield_pieces_per_kg === null ? null : Number(row.yield_pieces_per_kg),
|
|
markers: Array.isArray(row.markers) ? row.markers.filter(Boolean) : [],
|
|
components: Array.isArray(row.components) ? row.components.map(mapComponent) : [],
|
|
steps: Array.isArray(row.steps) ? row.steps.map(mapStep) : [],
|
|
createdAt: row.created_at || null,
|
|
updatedAt: row.updated_at || null
|
|
};
|
|
};
|
|
|
|
const getOrderById = async (id, client = pool) => {
|
|
const result = await client.query(`
|
|
SELECT
|
|
po.id,
|
|
po.tiny_id,
|
|
po.number,
|
|
po.status,
|
|
po.order_reference,
|
|
po.issue_date,
|
|
po.expected_date,
|
|
po.product_sku,
|
|
po.product_description,
|
|
po.quantity,
|
|
po.unit,
|
|
po.integration_status,
|
|
po.notes,
|
|
po.supplier,
|
|
po.lot_code,
|
|
po.roll_quantity,
|
|
po.fabric_kg,
|
|
po.rib_kg,
|
|
po.yield_pieces_per_kg,
|
|
po.created_at,
|
|
po.updated_at,
|
|
COALESCE(
|
|
(
|
|
SELECT JSON_AGG(
|
|
JSON_BUILD_OBJECT(
|
|
'label', marker.label,
|
|
'color', marker.color
|
|
)
|
|
ORDER BY marker.label
|
|
)
|
|
FROM production_order_markers marker
|
|
WHERE marker.production_order_id = po.id
|
|
),
|
|
'[]'::json
|
|
) as markers,
|
|
COALESCE(
|
|
(
|
|
SELECT JSON_AGG(
|
|
JSON_BUILD_OBJECT(
|
|
'id', component.id,
|
|
'component_tiny_id', component.component_tiny_id,
|
|
'component_sku', component.component_sku,
|
|
'component_name', component.component_name,
|
|
'quantity_per_unit', component.quantity_per_unit,
|
|
'total_quantity', component.total_quantity,
|
|
'unit', component.unit
|
|
)
|
|
ORDER BY component.id
|
|
)
|
|
FROM production_order_components component
|
|
WHERE component.production_order_id = po.id
|
|
),
|
|
'[]'::json
|
|
) as components,
|
|
COALESCE(
|
|
(
|
|
SELECT JSON_AGG(
|
|
JSON_BUILD_OBJECT(
|
|
'id', step.id,
|
|
'step_number', step.step_number,
|
|
'name', step.name,
|
|
'start_date', step.start_date,
|
|
'end_date', step.end_date,
|
|
'status', step.status,
|
|
'color', step.color
|
|
)
|
|
ORDER BY step.step_number NULLS LAST, step.id
|
|
)
|
|
FROM production_order_steps step
|
|
WHERE step.production_order_id = po.id
|
|
),
|
|
'[]'::json
|
|
) as steps
|
|
FROM production_orders po
|
|
WHERE po.id = $1;
|
|
`, [id]);
|
|
|
|
return result.rows[0] ? mapProductionOrderRow(result.rows[0]) : null;
|
|
};
|
|
|
|
const baseProductionOrderSelect = `
|
|
SELECT
|
|
po.id,
|
|
po.tiny_id,
|
|
po.number,
|
|
po.status,
|
|
po.order_reference,
|
|
po.issue_date,
|
|
po.expected_date,
|
|
po.product_sku,
|
|
po.product_description,
|
|
po.quantity,
|
|
po.unit,
|
|
po.integration_status,
|
|
po.notes,
|
|
po.supplier,
|
|
po.lot_code,
|
|
po.roll_quantity,
|
|
po.fabric_kg,
|
|
po.rib_kg,
|
|
po.yield_pieces_per_kg,
|
|
po.created_at,
|
|
po.updated_at,
|
|
COALESCE(
|
|
(
|
|
SELECT JSON_AGG(
|
|
JSON_BUILD_OBJECT(
|
|
'label', marker.label,
|
|
'color', marker.color
|
|
)
|
|
ORDER BY marker.label
|
|
)
|
|
FROM production_order_markers marker
|
|
WHERE marker.production_order_id = po.id
|
|
),
|
|
'[]'::json
|
|
) as markers,
|
|
COALESCE(
|
|
(
|
|
SELECT JSON_AGG(
|
|
JSON_BUILD_OBJECT(
|
|
'id', component.id,
|
|
'component_tiny_id', component.component_tiny_id,
|
|
'component_sku', component.component_sku,
|
|
'component_name', component.component_name,
|
|
'quantity_per_unit', component.quantity_per_unit,
|
|
'total_quantity', component.total_quantity,
|
|
'unit', component.unit
|
|
)
|
|
ORDER BY component.id
|
|
)
|
|
FROM production_order_components component
|
|
WHERE component.production_order_id = po.id
|
|
),
|
|
'[]'::json
|
|
) as components,
|
|
COALESCE(
|
|
(
|
|
SELECT JSON_AGG(
|
|
JSON_BUILD_OBJECT(
|
|
'id', step.id,
|
|
'step_number', step.step_number,
|
|
'name', step.name,
|
|
'start_date', step.start_date,
|
|
'end_date', step.end_date,
|
|
'status', step.status,
|
|
'color', step.color
|
|
)
|
|
ORDER BY step.step_number NULLS LAST, step.id
|
|
)
|
|
FROM production_order_steps step
|
|
WHERE step.production_order_id = po.id
|
|
),
|
|
'[]'::json
|
|
) as steps
|
|
FROM production_orders po
|
|
`;
|
|
|
|
const listProductionOrders = async (filters = {}) => {
|
|
const params = [];
|
|
const where = [];
|
|
const normalizedStart = normalizeDateParam(filters.start);
|
|
const normalizedEnd = normalizeDateParam(filters.end);
|
|
const normalizedSearch = String(filters.search || '').trim();
|
|
|
|
if (normalizedStart) {
|
|
params.push(normalizedStart);
|
|
where.push(`COALESCE(po.issue_date, po.expected_date, po.created_at::date) >= $${params.length}::date`);
|
|
}
|
|
|
|
if (normalizedEnd) {
|
|
params.push(normalizedEnd);
|
|
where.push(`COALESCE(po.issue_date, po.expected_date, po.created_at::date) <= $${params.length}::date`);
|
|
}
|
|
|
|
if (normalizedSearch) {
|
|
params.push(`%${normalizedSearch}%`);
|
|
where.push(`(
|
|
po.number ILIKE $${params.length}
|
|
OR po.order_reference ILIKE $${params.length}
|
|
OR po.product_sku ILIKE $${params.length}
|
|
OR po.product_description ILIKE $${params.length}
|
|
)`);
|
|
}
|
|
|
|
const result = await pool.query(`
|
|
${baseProductionOrderSelect}
|
|
${where.length ? `WHERE ${where.join(' AND ')}` : ''}
|
|
ORDER BY
|
|
COALESCE(po.issue_date, po.created_at::date) DESC,
|
|
CASE WHEN po.number ~ '^\\d+$' THEN po.number::bigint ELSE NULL END DESC NULLS LAST,
|
|
po.id DESC;
|
|
`, params);
|
|
|
|
const orders = result.rows.map(mapProductionOrderRow);
|
|
const counts = orders.reduce((nextCounts, order) => {
|
|
nextCounts.all += 1;
|
|
nextCounts[order.status] = (nextCounts[order.status] || 0) + 1;
|
|
return nextCounts;
|
|
}, {
|
|
all: 0,
|
|
open: 0,
|
|
in_progress: 0,
|
|
finished: 0,
|
|
canceled: 0
|
|
});
|
|
|
|
return { orders, counts };
|
|
};
|
|
|
|
const createProductionOrders = async (orders = []) => {
|
|
const client = await pool.connect();
|
|
|
|
try {
|
|
await client.query('BEGIN');
|
|
const created = [];
|
|
const skipped = [];
|
|
|
|
for (const order of orders) {
|
|
const productDescription = normalizeText(order.productDescription);
|
|
const productSku = normalizeText(order.productSku);
|
|
const orderReference = normalizeText(order.orderReference);
|
|
const quantity = normalizeQuantity(order.quantity);
|
|
|
|
if (!productDescription || !quantity) {
|
|
skipped.push({ productSku, productDescription, reason: 'invalid_payload' });
|
|
continue;
|
|
}
|
|
|
|
const duplicateResult = await client.query(`
|
|
SELECT id
|
|
FROM production_orders
|
|
WHERE COALESCE(order_reference, '') = $1
|
|
AND COALESCE(product_sku, '') = $2
|
|
AND status IN ('open', 'in_progress')
|
|
LIMIT 1;
|
|
`, [orderReference, productSku]);
|
|
|
|
if (duplicateResult.rows.length) {
|
|
skipped.push({ productSku, productDescription, reason: 'duplicate_open_order' });
|
|
continue;
|
|
}
|
|
|
|
const insertResult = await client.query(`
|
|
INSERT INTO production_orders (
|
|
tiny_id,
|
|
number,
|
|
status,
|
|
order_reference,
|
|
issue_date,
|
|
expected_date,
|
|
product_sku,
|
|
product_description,
|
|
quantity,
|
|
unit,
|
|
integration_status,
|
|
tiny_payload
|
|
)
|
|
VALUES (
|
|
NULL,
|
|
NULL,
|
|
$1,
|
|
$2,
|
|
$3,
|
|
$4,
|
|
$5,
|
|
$6,
|
|
$7,
|
|
$8,
|
|
$9,
|
|
$10::jsonb
|
|
)
|
|
RETURNING id;
|
|
`, [
|
|
normalizeStatus(order.status || 'open'),
|
|
orderReference,
|
|
normalizeDateParam(order.issueDate) || formatDate(new Date()),
|
|
normalizeDateParam(order.expectedDate),
|
|
productSku,
|
|
productDescription,
|
|
quantity,
|
|
normalizeText(order.unit) || 'UN',
|
|
normalizeText(order.integrationStatus) || 'Local',
|
|
JSON.stringify(order.metadata || {})
|
|
]);
|
|
|
|
const orderId = insertResult.rows[0].id;
|
|
await client.query(`
|
|
UPDATE production_orders
|
|
SET number = $1, updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = $2;
|
|
`, [normalizeText(order.number) || `OP-${String(orderId).padStart(5, '0')}`, orderId]);
|
|
|
|
const markers = Array.isArray(order.markers) ? order.markers : [];
|
|
for (const marker of markers) {
|
|
const label = normalizeText(marker.label);
|
|
if (!label) continue;
|
|
await client.query(`
|
|
INSERT INTO production_order_markers (production_order_id, label, color)
|
|
VALUES ($1, $2, $3)
|
|
ON CONFLICT (production_order_id, label) DO UPDATE SET color = EXCLUDED.color;
|
|
`, [orderId, label, normalizeText(marker.color) || null]);
|
|
}
|
|
|
|
const createdOrder = await getOrderById(orderId, client);
|
|
if (createdOrder) created.push(createdOrder);
|
|
}
|
|
|
|
await client.query('COMMIT');
|
|
return { created, skipped };
|
|
} catch (error) {
|
|
await client.query('ROLLBACK');
|
|
throw error;
|
|
} finally {
|
|
client.release();
|
|
}
|
|
};
|
|
|
|
const resolveTinyOrderPayload = (payload = {}) => {
|
|
const order = payload.order && typeof payload.order === 'object' ? payload.order : payload;
|
|
const quantity = normalizeQuantity(order.quantity);
|
|
const productDescription = normalizeText(order.productDescription || order.productName || order.produto || order.descricao);
|
|
|
|
if (!productDescription || !quantity) {
|
|
const error = new Error('Produto e quantidade da OP são obrigatórios.');
|
|
error.statusCode = 400;
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
tinyId: normalizeText(order.tinyId || order.tiny_id || order.idTiny || order.id),
|
|
number: normalizeText(order.number || order.numero || order.numeroOp || order.productionOrderNumber),
|
|
status: normalizeStatus(order.status || order.situacao || 'in_progress'),
|
|
orderReference: normalizeText(order.orderReference || order.reference || order.plano || order.pedidos),
|
|
issueDate: normalizeDateParam(order.issueDate || order.date || order.data),
|
|
expectedDate: normalizeDateParam(order.expectedDate || order.dataPrevista),
|
|
productSku: normalizeText(order.productSku || order.sku || order.codigo || order.codigoSku),
|
|
productDescription,
|
|
quantity,
|
|
unit: normalizeText(order.unit || order.unidade) || 'UN',
|
|
integrationStatus: normalizeText(order.integrationStatus) || 'Tiny',
|
|
notes: normalizeText(order.notes || order.observations || order.observacoes),
|
|
supplier: normalizeText(order.supplier || order.fornecedor),
|
|
lotCode: normalizeText(order.lotCode || order.lote),
|
|
rollQuantity: normalizeNullableQuantity(order.rollQuantity || order.quantidadeRolos),
|
|
fabricKg: normalizeNullableQuantity(order.fabricKg || order.quilosMalha),
|
|
ribKg: normalizeNullableQuantity(order.ribKg || order.quilosRibana),
|
|
yieldPiecesPerKg: normalizeNullableQuantity(order.yieldPiecesPerKg || order.rendimento),
|
|
rawPayload: payload
|
|
};
|
|
};
|
|
|
|
const normalizeComponents = (components = [], orderQuantity = 0) => (
|
|
Array.isArray(components) ? components : []
|
|
).map(component => {
|
|
const quantityPerUnit = normalizeQuantity(component.quantityPerUnit || component.quantity || component.quantidade);
|
|
const totalQuantity = normalizeQuantity(component.totalQuantity || component.quantidadeTotal) || quantityPerUnit * orderQuantity;
|
|
|
|
return {
|
|
componentTinyId: normalizeText(component.componentTinyId || component.idComponente || component.id_componente || component.id),
|
|
componentSku: normalizeText(component.componentSku || component.sku || component.codigo || component.code),
|
|
componentName: normalizeText(component.componentName || component.name || component.nome || component.produto),
|
|
quantityPerUnit,
|
|
totalQuantity,
|
|
unit: normalizeText(component.unit || component.unidade)
|
|
};
|
|
}).filter(component => component.componentName);
|
|
|
|
const normalizeSteps = (steps = []) => (
|
|
Array.isArray(steps) ? steps : []
|
|
).map(step => ({
|
|
stepNumber: normalizeInteger(step.stepNumber || step.number || step.nro || step.numero),
|
|
name: normalizeText(step.name || step.etapa || step.posto || step.description),
|
|
startDate: normalizeDateParam(step.startDate || step.dataInicio),
|
|
endDate: normalizeDateParam(step.endDate || step.dataFim),
|
|
status: normalizeText(step.status || step.situacao),
|
|
color: normalizeText(step.color || step.cor)
|
|
})).filter(step => step.name);
|
|
|
|
const upsertTinyProductionOrderDetail = async (payload = {}) => {
|
|
const order = resolveTinyOrderPayload(payload);
|
|
const components = normalizeComponents(payload.components || payload.composition || payload.composicao, order.quantity);
|
|
const steps = normalizeSteps(payload.steps || payload.etapas);
|
|
const client = await pool.connect();
|
|
|
|
try {
|
|
await client.query('BEGIN');
|
|
|
|
const existingResult = await client.query(`
|
|
SELECT id
|
|
FROM production_orders
|
|
WHERE ($1 <> '' AND tiny_id = $1)
|
|
OR ($2 <> '' AND number = $2)
|
|
ORDER BY CASE WHEN tiny_id = $1 THEN 0 ELSE 1 END
|
|
LIMIT 1;
|
|
`, [order.tinyId, order.number]);
|
|
|
|
let orderId = existingResult.rows[0]?.id;
|
|
|
|
if (orderId) {
|
|
await client.query(`
|
|
UPDATE production_orders
|
|
SET tiny_id = COALESCE(NULLIF($1, ''), tiny_id),
|
|
number = COALESCE(NULLIF($2, ''), number),
|
|
status = $3,
|
|
order_reference = NULLIF($4, ''),
|
|
issue_date = $5,
|
|
expected_date = $6,
|
|
product_sku = NULLIF($7, ''),
|
|
product_description = $8,
|
|
quantity = $9,
|
|
unit = $10,
|
|
integration_status = $11,
|
|
notes = NULLIF($12, ''),
|
|
supplier = NULLIF($13, ''),
|
|
lot_code = NULLIF($14, ''),
|
|
roll_quantity = $15,
|
|
fabric_kg = $16,
|
|
rib_kg = $17,
|
|
yield_pieces_per_kg = $18,
|
|
tiny_payload = $19::jsonb,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = $20;
|
|
`, [
|
|
order.tinyId,
|
|
order.number,
|
|
order.status,
|
|
order.orderReference,
|
|
order.issueDate,
|
|
order.expectedDate,
|
|
order.productSku,
|
|
order.productDescription,
|
|
order.quantity,
|
|
order.unit,
|
|
order.integrationStatus,
|
|
order.notes,
|
|
order.supplier,
|
|
order.lotCode,
|
|
order.rollQuantity,
|
|
order.fabricKg,
|
|
order.ribKg,
|
|
order.yieldPiecesPerKg,
|
|
JSON.stringify(order.rawPayload),
|
|
orderId
|
|
]);
|
|
} else {
|
|
const insertResult = await client.query(`
|
|
INSERT INTO production_orders (
|
|
tiny_id, number, status, order_reference, issue_date, expected_date,
|
|
product_sku, product_description, quantity, unit, integration_status,
|
|
notes, supplier, lot_code, roll_quantity, fabric_kg, rib_kg,
|
|
yield_pieces_per_kg, tiny_payload
|
|
)
|
|
VALUES (
|
|
NULLIF($1, ''), NULLIF($2, ''), $3, NULLIF($4, ''), $5, $6,
|
|
NULLIF($7, ''), $8, $9, $10, $11, NULLIF($12, ''),
|
|
NULLIF($13, ''), NULLIF($14, ''), $15, $16, $17, $18, $19::jsonb
|
|
)
|
|
RETURNING id;
|
|
`, [
|
|
order.tinyId,
|
|
order.number,
|
|
order.status,
|
|
order.orderReference,
|
|
order.issueDate,
|
|
order.expectedDate,
|
|
order.productSku,
|
|
order.productDescription,
|
|
order.quantity,
|
|
order.unit,
|
|
order.integrationStatus,
|
|
order.notes,
|
|
order.supplier,
|
|
order.lotCode,
|
|
order.rollQuantity,
|
|
order.fabricKg,
|
|
order.ribKg,
|
|
order.yieldPiecesPerKg,
|
|
JSON.stringify(order.rawPayload)
|
|
]);
|
|
orderId = insertResult.rows[0].id;
|
|
}
|
|
|
|
await client.query('DELETE FROM production_order_components WHERE production_order_id = $1;', [orderId]);
|
|
for (const component of components) {
|
|
await client.query(`
|
|
INSERT INTO production_order_components (
|
|
production_order_id, component_tiny_id, component_sku, component_name,
|
|
quantity_per_unit, total_quantity, unit
|
|
)
|
|
VALUES ($1, NULLIF($2, ''), NULLIF($3, ''), $4, $5, $6, NULLIF($7, ''));
|
|
`, [
|
|
orderId,
|
|
component.componentTinyId,
|
|
component.componentSku,
|
|
component.componentName,
|
|
component.quantityPerUnit,
|
|
component.totalQuantity,
|
|
component.unit
|
|
]);
|
|
}
|
|
|
|
await client.query('DELETE FROM production_order_steps WHERE production_order_id = $1;', [orderId]);
|
|
for (const step of steps) {
|
|
await client.query(`
|
|
INSERT INTO production_order_steps (
|
|
production_order_id, step_number, name, start_date, end_date, status, color
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, NULLIF($6, ''), NULLIF($7, ''));
|
|
`, [
|
|
orderId,
|
|
step.stepNumber,
|
|
step.name,
|
|
step.startDate,
|
|
step.endDate,
|
|
step.status,
|
|
step.color
|
|
]);
|
|
}
|
|
|
|
await client.query('COMMIT');
|
|
return {
|
|
order: await getOrderById(orderId),
|
|
componentCount: components.length,
|
|
stepCount: steps.length
|
|
};
|
|
} catch (error) {
|
|
await client.query('ROLLBACK');
|
|
throw error;
|
|
} finally {
|
|
client.release();
|
|
}
|
|
};
|
|
|
|
const updateProductionOrderStatus = async (id, status) => {
|
|
const normalizedStatus = normalizeStatus(status);
|
|
|
|
if (!STATUS_LABELS[normalizedStatus]) {
|
|
const error = new Error('Invalid production order status');
|
|
error.statusCode = 400;
|
|
throw error;
|
|
}
|
|
|
|
const result = await pool.query(`
|
|
UPDATE production_orders
|
|
SET status = $1, updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = $2
|
|
RETURNING id;
|
|
`, [normalizedStatus, id]);
|
|
|
|
if (!result.rows.length) {
|
|
const error = new Error('Production order not found');
|
|
error.statusCode = 404;
|
|
throw error;
|
|
}
|
|
|
|
return getOrderById(id);
|
|
};
|
|
|
|
module.exports = {
|
|
createProductionOrders,
|
|
listProductionOrders,
|
|
normalizeStatus,
|
|
upsertTinyProductionOrderDetail,
|
|
updateProductionOrderStatus
|
|
};
|