393 lines
12 KiB
JavaScript
393 lines
12 KiB
JavaScript
const { pool } = require('../db');
|
|
|
|
const normalizeText = (value) => String(value || '').replace(/\s+/g, ' ').trim();
|
|
|
|
const normalizeNumber = (value) => {
|
|
if (value === '' || value === null || value === undefined) return null;
|
|
const number = Number(String(value).replace(',', '.'));
|
|
return Number.isFinite(number) && number > 0 ? number : null;
|
|
};
|
|
|
|
const normalizeKey = (value) => normalizeText(value)
|
|
.normalize('NFD')
|
|
.replace(/[\u0300-\u036f]/g, '')
|
|
.toLowerCase();
|
|
|
|
const mapReceipt = (row) => ({
|
|
id: row.id,
|
|
category: row.category,
|
|
product: row.product,
|
|
quantity: Number(row.quantity),
|
|
unit: row.unit,
|
|
supplier: row.supplier || '',
|
|
invoice: row.invoice || '',
|
|
notes: row.notes || '',
|
|
status: row.status,
|
|
createdAt: row.created_at,
|
|
updatedAt: row.updated_at,
|
|
approvedAt: row.approved_at
|
|
});
|
|
|
|
const mapLot = (row) => ({
|
|
id: row.id,
|
|
receiptId: row.receipt_id,
|
|
category: row.category,
|
|
product: row.product,
|
|
quantity: Number(row.quantity),
|
|
unit: row.unit,
|
|
supplier: row.supplier || '',
|
|
invoice: row.invoice || '',
|
|
status: row.status,
|
|
createdAt: row.created_at,
|
|
updatedAt: row.updated_at
|
|
});
|
|
|
|
const mapMovement = (row) => ({
|
|
id: row.id,
|
|
receiptId: row.receipt_id,
|
|
lotId: row.lot_id,
|
|
type: row.type,
|
|
category: row.category,
|
|
product: row.product,
|
|
quantity: Number(row.quantity),
|
|
unit: row.unit,
|
|
reason: row.reason || '',
|
|
createdAt: row.created_at
|
|
});
|
|
|
|
const mapFabricPlan = (row) => ({
|
|
id: row.id,
|
|
material: row.material,
|
|
color: row.color || '',
|
|
quantityKg: Number(row.quantity_kg),
|
|
supplier: row.supplier || '',
|
|
priority: row.priority,
|
|
status: row.status,
|
|
createdAt: row.created_at,
|
|
updatedAt: row.updated_at
|
|
});
|
|
|
|
const createValidationError = (message) => {
|
|
const error = new Error(message);
|
|
error.statusCode = 400;
|
|
return error;
|
|
};
|
|
|
|
const listReceipts = async () => {
|
|
const result = await pool.query(`
|
|
SELECT id, category, product, quantity, unit, supplier, invoice, notes, status, created_at, updated_at, approved_at
|
|
FROM supply_receipts
|
|
ORDER BY created_at DESC, id DESC
|
|
`);
|
|
return result.rows.map(mapReceipt);
|
|
};
|
|
|
|
const listLots = async () => {
|
|
const result = await pool.query(`
|
|
SELECT id, receipt_id, category, product, quantity, unit, supplier, invoice, status, created_at, updated_at
|
|
FROM supply_stock_lots
|
|
WHERE status = 'active'
|
|
ORDER BY created_at DESC, id DESC
|
|
`);
|
|
return result.rows.map(mapLot);
|
|
};
|
|
|
|
const listMovements = async () => {
|
|
const result = await pool.query(`
|
|
SELECT id, receipt_id, lot_id, type, category, product, quantity, unit, reason, created_at
|
|
FROM supply_movements
|
|
ORDER BY created_at DESC, id DESC
|
|
`);
|
|
return result.rows.map(mapMovement);
|
|
};
|
|
|
|
const listFabricPlans = async () => {
|
|
const result = await pool.query(`
|
|
SELECT id, material, color, quantity_kg, supplier, priority, status, created_at, updated_at
|
|
FROM supply_fabric_plans
|
|
WHERE status = 'active'
|
|
ORDER BY
|
|
CASE priority
|
|
WHEN 'Crítico' THEN 1
|
|
WHEN 'Atenção' THEN 2
|
|
ELSE 3
|
|
END,
|
|
created_at DESC,
|
|
id DESC
|
|
`);
|
|
return result.rows.map(mapFabricPlan);
|
|
};
|
|
|
|
const buildPurchaseNeeds = (plans, lots, receipts) => {
|
|
const needsByMaterial = new Map();
|
|
|
|
plans.forEach(plan => {
|
|
const key = normalizeKey(plan.material);
|
|
if (!key) return;
|
|
|
|
const current = needsByMaterial.get(key) || {
|
|
material: plan.material,
|
|
plannedKg: 0,
|
|
stockKg: 0,
|
|
pendingKg: 0,
|
|
purchaseKg: 0,
|
|
priority: 'Normal',
|
|
suppliers: new Set(),
|
|
colors: new Set()
|
|
};
|
|
|
|
current.plannedKg += plan.quantityKg;
|
|
if (plan.supplier) current.suppliers.add(plan.supplier);
|
|
if (plan.color) current.colors.add(plan.color);
|
|
if (plan.priority === 'Crítico') current.priority = 'Crítico';
|
|
if (plan.priority === 'Atenção' && current.priority !== 'Crítico') current.priority = 'Atenção';
|
|
needsByMaterial.set(key, current);
|
|
});
|
|
|
|
lots.forEach(lot => {
|
|
if (lot.unit !== 'kg') return;
|
|
const need = needsByMaterial.get(normalizeKey(lot.product));
|
|
if (need) need.stockKg += lot.quantity;
|
|
});
|
|
|
|
receipts.forEach(receipt => {
|
|
if (receipt.status !== 'pending' || receipt.unit !== 'kg') return;
|
|
const need = needsByMaterial.get(normalizeKey(receipt.product));
|
|
if (need) need.pendingKg += receipt.quantity;
|
|
});
|
|
|
|
return Array.from(needsByMaterial.values())
|
|
.map(need => {
|
|
const purchaseKg = Math.max(need.plannedKg - need.stockKg - need.pendingKg, 0);
|
|
let status = 'ok';
|
|
if (purchaseKg > 0 && (need.priority === 'Crítico' || need.stockKg === 0)) status = 'critical';
|
|
else if (purchaseKg > 0) status = 'attention';
|
|
|
|
return {
|
|
material: need.material,
|
|
plannedKg: need.plannedKg,
|
|
stockKg: need.stockKg,
|
|
pendingKg: need.pendingKg,
|
|
purchaseKg,
|
|
priority: need.priority,
|
|
status,
|
|
suppliers: Array.from(need.suppliers),
|
|
colors: Array.from(need.colors)
|
|
};
|
|
})
|
|
.sort((a, b) => {
|
|
const statusOrder = { critical: 1, attention: 2, ok: 3 };
|
|
return statusOrder[a.status] - statusOrder[b.status] || b.purchaseKg - a.purchaseKg || a.material.localeCompare(b.material);
|
|
});
|
|
};
|
|
|
|
const buildStats = (receipts, lots, purchaseNeeds) => {
|
|
const totalQuantityKg = lots.reduce((total, lot) => (
|
|
lot.unit === 'kg' ? total + lot.quantity : total
|
|
), 0);
|
|
|
|
return {
|
|
totalQuantityKg,
|
|
activeLots: lots.length,
|
|
rolls: lots.filter(lot => lot.unit === 'rolos').reduce((total, lot) => total + lot.quantity, 0),
|
|
alerts: purchaseNeeds.filter(need => need.status !== 'ok').length,
|
|
pendingReceipts: receipts.filter(receipt => receipt.status === 'pending').length,
|
|
approvedReceipts: receipts.filter(receipt => receipt.status === 'approved').length
|
|
};
|
|
};
|
|
|
|
const getSupplySummary = async () => {
|
|
const [receipts, lots, movements, fabricPlans] = await Promise.all([
|
|
listReceipts(),
|
|
listLots(),
|
|
listMovements(),
|
|
listFabricPlans()
|
|
]);
|
|
const purchaseNeeds = buildPurchaseNeeds(fabricPlans, lots, receipts);
|
|
|
|
return {
|
|
receipts,
|
|
lots,
|
|
movements,
|
|
fabricPlans,
|
|
purchaseNeeds,
|
|
stats: buildStats(receipts, lots, purchaseNeeds)
|
|
};
|
|
};
|
|
|
|
const listPurchaseNeeds = async () => {
|
|
const [plans, lots, receipts] = await Promise.all([
|
|
listFabricPlans(),
|
|
listLots(),
|
|
listReceipts()
|
|
]);
|
|
|
|
return buildPurchaseNeeds(plans, lots, receipts);
|
|
};
|
|
|
|
const createReceipt = async (payload) => {
|
|
const category = normalizeText(payload.category);
|
|
const product = normalizeText(payload.product);
|
|
const quantity = normalizeNumber(payload.quantity);
|
|
const unit = normalizeText(payload.unit) || 'kg';
|
|
|
|
if (!category) throw createValidationError('Categoria é obrigatória.');
|
|
if (!product) throw createValidationError('Produto ou material é obrigatório.');
|
|
if (!quantity) throw createValidationError('Quantidade deve ser maior que zero.');
|
|
|
|
const result = await pool.query(`
|
|
INSERT INTO supply_receipts (
|
|
category, product, quantity, unit, supplier, invoice, notes, status, updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, 'pending', CURRENT_TIMESTAMP)
|
|
RETURNING id, category, product, quantity, unit, supplier, invoice, notes, status, created_at, updated_at, approved_at
|
|
`, [
|
|
category,
|
|
product,
|
|
quantity,
|
|
unit,
|
|
normalizeText(payload.supplier) || null,
|
|
normalizeText(payload.invoice) || null,
|
|
normalizeText(payload.notes) || null
|
|
]);
|
|
|
|
return mapReceipt(result.rows[0]);
|
|
};
|
|
|
|
const approveReceipt = async (id) => {
|
|
const client = await pool.connect();
|
|
|
|
try {
|
|
await client.query('BEGIN');
|
|
|
|
const receiptResult = await client.query(`
|
|
SELECT id, category, product, quantity, unit, supplier, invoice, notes, status, created_at, updated_at, approved_at
|
|
FROM supply_receipts
|
|
WHERE id = $1
|
|
FOR UPDATE
|
|
`, [id]);
|
|
|
|
if (!receiptResult.rowCount) {
|
|
throw createValidationError('Recebimento não encontrado.');
|
|
}
|
|
|
|
const receipt = receiptResult.rows[0];
|
|
if (receipt.status === 'approved') {
|
|
await client.query('COMMIT');
|
|
return mapReceipt(receipt);
|
|
}
|
|
|
|
const updatedReceiptResult = await client.query(`
|
|
UPDATE supply_receipts
|
|
SET status = 'approved',
|
|
approved_at = CURRENT_TIMESTAMP,
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = $1
|
|
RETURNING id, category, product, quantity, unit, supplier, invoice, notes, status, created_at, updated_at, approved_at
|
|
`, [id]);
|
|
|
|
const lotResult = await client.query(`
|
|
INSERT INTO supply_stock_lots (
|
|
receipt_id, category, product, quantity, unit, supplier, invoice, status, updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, 'active', CURRENT_TIMESTAMP)
|
|
RETURNING id
|
|
`, [
|
|
receipt.id,
|
|
receipt.category,
|
|
receipt.product,
|
|
receipt.quantity,
|
|
receipt.unit,
|
|
receipt.supplier,
|
|
receipt.invoice
|
|
]);
|
|
|
|
await client.query(`
|
|
INSERT INTO supply_movements (
|
|
receipt_id, lot_id, type, category, product, quantity, unit, reason
|
|
)
|
|
VALUES ($1, $2, 'receipt', $3, $4, $5, $6, $7)
|
|
`, [
|
|
receipt.id,
|
|
lotResult.rows[0].id,
|
|
receipt.category,
|
|
receipt.product,
|
|
receipt.quantity,
|
|
receipt.unit,
|
|
`Recebimento aprovado${receipt.invoice ? ` · NF ${receipt.invoice}` : ''}`
|
|
]);
|
|
|
|
await client.query('COMMIT');
|
|
return mapReceipt(updatedReceiptResult.rows[0]);
|
|
} catch (error) {
|
|
await client.query('ROLLBACK');
|
|
throw error;
|
|
} finally {
|
|
client.release();
|
|
}
|
|
};
|
|
|
|
const deleteReceipt = async (id) => {
|
|
const client = await pool.connect();
|
|
|
|
try {
|
|
await client.query('BEGIN');
|
|
await client.query('DELETE FROM supply_movements WHERE receipt_id = $1', [id]);
|
|
await client.query('DELETE FROM supply_stock_lots WHERE receipt_id = $1', [id]);
|
|
await client.query('DELETE FROM supply_receipts WHERE id = $1', [id]);
|
|
await client.query('COMMIT');
|
|
} catch (error) {
|
|
await client.query('ROLLBACK');
|
|
throw error;
|
|
} finally {
|
|
client.release();
|
|
}
|
|
};
|
|
|
|
const createFabricPlan = async (payload) => {
|
|
const material = normalizeText(payload.material);
|
|
const quantityKg = normalizeNumber(payload.quantityKg);
|
|
|
|
if (!material) throw createValidationError('Malha ou tecido é obrigatório.');
|
|
if (!quantityKg) throw createValidationError('Quantidade deve ser maior que zero.');
|
|
|
|
const result = await pool.query(`
|
|
INSERT INTO supply_fabric_plans (
|
|
material, color, quantity_kg, supplier, priority, status, updated_at
|
|
)
|
|
VALUES ($1, $2, $3, $4, $5, 'active', CURRENT_TIMESTAMP)
|
|
RETURNING id, material, color, quantity_kg, supplier, priority, status, created_at, updated_at
|
|
`, [
|
|
material,
|
|
normalizeText(payload.color) || 'Todas as cores',
|
|
quantityKg,
|
|
normalizeText(payload.supplier) || null,
|
|
normalizeText(payload.priority) || 'Normal'
|
|
]);
|
|
|
|
return mapFabricPlan(result.rows[0]);
|
|
};
|
|
|
|
const deleteFabricPlan = async (id) => {
|
|
await pool.query(`
|
|
UPDATE supply_fabric_plans
|
|
SET status = 'removed',
|
|
updated_at = CURRENT_TIMESTAMP
|
|
WHERE id = $1
|
|
`, [id]);
|
|
};
|
|
|
|
module.exports = {
|
|
approveReceipt,
|
|
createFabricPlan,
|
|
createReceipt,
|
|
deleteFabricPlan,
|
|
deleteReceipt,
|
|
getSupplySummary,
|
|
listFabricPlans,
|
|
listLots,
|
|
listMovements,
|
|
listPurchaseNeeds,
|
|
listReceipts
|
|
};
|