shutro-erp 0.3.6 → 0.3.7

package/dist/stock/ledger.js

@@ -0,0 +1,582 @@
+/**
+ * The stock ledger and the stock report (RFC 0032 §3.3), over HTTP:
+ *
+ * - `GET /api/v1/stockroom/ledger?from&to&mode=summary|details&warehouses=1,2&locations=&categories=&products=`
+ *   — for a period and a scope of locations (chosen warehouses' stock, or chosen locations; every warehouse
+ *   otherwise), per product: the opening quantity, what came in by **movement type** (purchase receipt, sales
+ *   return, production, transfer in, adjustment, other), what went out by type (sales delivery, purchase return,
+ *   production consumption, transfer out, internal use, scrap, adjustment, other) and the closing quantity; or every
+ *   movement of the period. Movement types come from where the goods came from and went to, never typed by hand.
+ *   With `stock_account`, and for people who may read the valuation, each figure carries its value.
+ * - `GET /api/v1/stockroom/stock?warehouses&locations&categories&products` — on hand, reserved, available, incoming
+ *   and outgoing per product and location in the scope.
+ *
+ * Both as JSON for the screen, or with `format=xlsx` / `format=pdf` as a file (the export right; audited).
+ */
+import { moneyFormat, renderPdf, workbook } from '../reporting/index.js';
+import { audit, HttpProblem } from '../server/index.js';
+import { orm } from '../server/orm.js';
+const zero = orm.toDecimal(0);
+export const IN_TYPES = [
+    'purchase_receipt',
+    'sales_return',
+    'production_in',
+    'transfer_in',
+    'adjustment_in',
+    'other_in',
+];
+export const OUT_TYPES = [
+    'sales_delivery',
+    'purchase_return',
+    'production_out',
+    'transfer_out',
+    'consumption',
+    'scrap',
+    'adjustment_out',
+    'other_out',
+];
+export const TYPE_LABELS = {
+    purchase_receipt: 'Purchase receipt',
+    sales_return: 'Sales return',
+    production_in: 'Production in',
+    transfer_in: 'Transfer in',
+    adjustment_in: 'Adjustment in',
+    other_in: 'Other in',
+    sales_delivery: 'Sales delivery',
+    purchase_return: 'Purchase return',
+    production_out: 'Production out',
+    transfer_out: 'Transfer out',
+    consumption: 'Internal use',
+    scrap: 'Scrap',
+    adjustment_out: 'Adjustment out',
+    other_out: 'Other out',
+};
+/** A date-only value as `YYYY-MM-DD`. */
+export function isoDay(v) {
+    if (!(v instanceof Date))
+        return String(v ?? '').slice(0, 10);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${v.getFullYear()}-${pad(v.getMonth() + 1)}-${pad(v.getDate())}`;
+}
+/**
+ * The locations the scope covers — the chosen locations and what is inside them, or the stock of the chosen (else
+ * every) warehouses — with every location's name. Transit locations count only when chosen by name.
+ */
+async function insideLocations(env, scope) {
+    const loaded = await (await env.model('stock.location').search({})).load({
+        parent: true,
+        warehouse: true,
+    });
+    const all = [...loaded].map((l) => ({
+        id: l.id,
+        name: l.fullName ?? l.name,
+        usage: l.usage,
+        parent: l.parent?.id ?? null,
+        warehouse: l.warehouse?.id ?? null,
+        transit: l.transit === true,
+    }));
+    const places = new Map(all.map((l) => [l.id, l]));
+    const roots = new Set(scope.locations);
+    if (roots.size === 0)
+        for (const l of all)
+            if (l.usage === 'internal' &&
+                !l.transit &&
+                l.parent === null &&
+                l.warehouse !== null &&
+                (scope.warehouses.length === 0 || scope.warehouses.includes(l.warehouse)))
+                roots.add(l.id);
+    const inside = new Set();
+    for (const l of all) {
+        let p = l;
+        for (let depth = 0; p !== undefined && depth < 30; depth += 1) {
+            if (roots.has(p.id)) {
+                if (!l.transit || scope.locations.includes(l.id))
+                    inside.add(l.id);
+                break;
+            }
+            p = p.parent === null ? undefined : places.get(p.parent);
+        }
+    }
+    return { inside, names: new Map(all.map((l) => [l.id, l.name])), places };
+}
+/** Whether this person may see stock values (`stock_account` installed and the valuation readable). */
+function canValue(env) {
+    try {
+        return env.access.can('stock.valuation.layer', 'read');
+    }
+    catch {
+        return false;
+    }
+}
+/** The done lines whose transfer was done in `[from, to]` (both optional), in the scope's products. */
+async function doneLines(env, scope, from, to) {
+    const where = { 'picking.state': 'done' };
+    if (from !== null && to !== null)
+        where['picking.doneDate'] = { gte: from, lte: to };
+    else if (to !== null)
+        where['picking.doneDate'] = { lte: to };
+    else if (from !== null)
+        where['picking.doneDate'] = { gte: from };
+    if (scope.products.length > 0)
+        where['product'] = { in: scope.products };
+    if (scope.categories.length > 0)
+        where['product.category'] = { in: scope.categories };
+    const found = await env.model('stock.move').search({ where: where, limit: 200000 });
+    return found.load({
+        picking: { source: true, destination: true },
+        product: { uom: true },
+        destination: true,
+    });
+}
+/** Where a line's goods came from and went to against the scope: in, out, or inside only (null). */
+function classify(line, inside, places) {
+    const sourceId = line.picking.source.id;
+    const destinationId = (line.destination?.id ?? line.picking.destination.id);
+    const sIn = inside.has(sourceId);
+    const dIn = inside.has(destinationId);
+    if (sIn === dIn)
+        return null;
+    if (dIn) {
+        const usage = places.get(sourceId)?.usage ?? line.picking.source.usage;
+        const type = usage === 'vendor'
+            ? 'purchase_receipt'
+            : usage === 'customer'
+                ? 'sales_return'
+                : usage === 'production'
+                    ? 'production_in'
+                    : usage === 'adjustment'
+                        ? 'adjustment_in'
+                        : usage === 'internal' || usage === 'transit' || usage === 'consumption'
+                            ? 'transfer_in'
+                            : 'other_in';
+        return { dir: 'in', type };
+    }
+    const place = places.get(destinationId);
+    const usage = place?.usage ?? line.picking.destination.usage;
+    const type = usage === 'customer'
+        ? 'sales_delivery'
+        : usage === 'vendor'
+            ? 'purchase_return'
+            : usage === 'production'
+                ? 'production_out'
+                : usage === 'adjustment'
+                    ? (place?.name ?? '').endsWith('Scrap')
+                        ? 'scrap'
+                        : 'adjustment_out'
+                    : usage === 'consumption'
+                        ? 'consumption'
+                        : usage === 'internal' || usage === 'transit'
+                            ? 'transfer_out'
+                            : 'other_out';
+    return { dir: 'out', type };
+}
+/** Each line's value as it moved (signed), from the valuation when readable, else at the product's cost. */
+async function valuesOf(env, lines, valued) {
+    const out = new Map();
+    if (!valued)
+        return out;
+    const ids = lines.map((l) => l.id);
+    const given = new Map();
+    for (let i = 0; i < ids.length; i += 2000) {
+        const chunk = ids.slice(i, i + 2000);
+        const values = await env
+            .model('stock.move')
+            .browse(chunk)
+            .moveValues();
+        for (const [id, v] of values)
+            given.set(id, orm.toDecimal(v));
+    }
+    for (const l of lines) {
+        const v = given.get(l.id);
+        if (v !== undefined && !v.eq(0))
+            out.set(l.id, v.abs());
+        else
+            out.set(l.id, (l.doneQty ?? zero).times(l.product.standardPrice ?? zero).abs());
+    }
+    return out;
+}
+const figure = () => ({ qty: zero, value: zero });
+const add = (f, qty, value) => {
+    f.qty = f.qty.plus(qty);
+    f.value = f.value.plus(value);
+};
+const productOf = (l) => ({
+    id: l.product.id,
+    name: l.product.name,
+    uom: l.product.uom?.name ?? '',
+});
+/** The ledger's summary: per product, opening, in and out by type, closing. */
+export async function ledgerSummary(env, scope, from, to) {
+    const valued = canValue(env);
+    const { inside, places } = await insideLocations(env, scope);
+    const before = [...(await doneLines(env, scope, null, isoDay(dayBefore(from))))];
+    const during = [...(await doneLines(env, scope, from, to))];
+    const values = await valuesOf(env, [...before, ...during], valued);
+    const rows = new Map();
+    const rowOf = (l) => {
+        const id = l.product.id;
+        let r = rows.get(id);
+        if (r === undefined) {
+            r = {
+                product: productOf(l),
+                opening: figure(),
+                in: Object.fromEntries(IN_TYPES.map((t) => [t, figure()])),
+                out: Object.fromEntries(OUT_TYPES.map((t) => [t, figure()])),
+            };
+            rows.set(id, r);
+        }
+        return r;
+    };
+    for (const l of before) {
+        const c = classify(l, inside, places);
+        if (c === null)
+            continue;
+        const qty = l.doneQty ?? zero;
+        const value = values.get(l.id) ?? zero;
+        const r = rowOf(l);
+        add(r.opening, c.dir === 'in' ? qty : qty.negated(), c.dir === 'in' ? value : value.negated());
+    }
+    for (const l of during) {
+        const c = classify(l, inside, places);
+        if (c === null)
+            continue;
+        const r = rowOf(l);
+        const qty = l.doneQty ?? zero;
+        const value = values.get(l.id) ?? zero;
+        if (c.dir === 'in')
+            add(r.in[c.type], qty, value);
+        else
+            add(r.out[c.type], qty, value);
+    }
+    const out = [...rows.values()]
+        .map((r) => {
+        const totalIn = figure();
+        const totalOut = figure();
+        for (const t of IN_TYPES)
+            add(totalIn, r.in[t].qty, r.in[t].value);
+        for (const t of OUT_TYPES)
+            add(totalOut, r.out[t].qty, r.out[t].value);
+        const closing = {
+            qty: r.opening.qty.plus(totalIn.qty).minus(totalOut.qty),
+            value: r.opening.value.plus(totalIn.value).minus(totalOut.value),
+        };
+        return { ...r, totalIn, totalOut, closing };
+    })
+        .filter((r) => !r.opening.qty.eq(0) || !r.totalIn.qty.eq(0) || !r.totalOut.qty.eq(0))
+        .sort((a, b) => a.product.name.localeCompare(b.product.name));
+    return { valued, rows: out };
+}
+/** The ledger's details: every movement of the period in the scope. */
+export async function ledgerDetails(env, scope, from, to) {
+    const valued = canValue(env);
+    const { inside, names, places } = await insideLocations(env, scope);
+    const during = [...(await doneLines(env, scope, from, to))];
+    const values = await valuesOf(env, during, valued);
+    const rows = [];
+    for (const l of during) {
+        const c = classify(l, inside, places);
+        if (c === null)
+            continue;
+        const qty = l.doneQty ?? zero;
+        const value = values.get(l.id) ?? zero;
+        const destination = (l.destination?.id ?? l.picking.destination.id);
+        rows.push({
+            date: isoDay(l.picking.doneDate),
+            reference: l.picking.name,
+            origin: l.picking.origin ?? null,
+            product: productOf(l),
+            from: names.get(l.picking.source.id) ?? '',
+            to: names.get(destination) ?? '',
+            type: c.type,
+            qty: c.dir === 'in' ? qty : qty.negated(),
+            value: c.dir === 'in' ? value : value.negated(),
+        });
+    }
+    rows.sort((a, b) => a.date.localeCompare(b.date) ||
+        a.reference.localeCompare(b.reference) ||
+        a.product.name.localeCompare(b.product.name));
+    return { valued, rows };
+}
+/** The stock report: on hand, reserved, available, incoming and outgoing per product and location in the scope. */
+export async function stockReport(env, scope) {
+    const { inside, names } = await insideLocations(env, scope);
+    const where = { location: { in: [...inside] } };
+    if (scope.products.length > 0)
+        where['product'] = { in: scope.products };
+    if (scope.categories.length > 0)
+        where['product.category'] = { in: scope.categories };
+    const quants = await (await env.model('stock.quant').search({ where: where, limit: 200000 })).load({ product: { uom: true }, location: true });
+    const rows = new Map();
+    const rowOf = (product, location) => {
+        const key = `${product.id}:${location.id}`;
+        let r = rows.get(key);
+        if (r === undefined) {
+            r = { product, location, onHand: zero, reserved: zero, incoming: zero, outgoing: zero };
+            rows.set(key, r);
+        }
+        return r;
+    };
+    for (const q of quants) {
+        const r = rowOf({ id: q.product.id, name: q.product.name, uom: q.product.uom?.name ?? '' }, { id: q.location.id, name: names.get(q.location.id) ?? '' });
+        r.onHand = r.onHand.plus(q.quantity);
+        r.reserved = r.reserved.plus(q.reserved ?? zero);
+    }
+    // What confirmed transfers will bring in or take out.
+    const openWhere = { 'picking.state': 'confirmed' };
+    if (scope.products.length > 0)
+        openWhere['product'] = { in: scope.products };
+    if (scope.categories.length > 0)
+        openWhere['product.category'] = { in: scope.categories };
+    const open = await (await env.model('stock.move').search({ where: openWhere, limit: 200000 })).load({
+        picking: { source: true, destination: true },
+        product: { uom: true },
+        destination: true,
+    });
+    for (const m of open) {
+        const sourceId = m.picking.source.id;
+        const destinationId = (m.destination?.id ?? m.picking.destination.id);
+        const sIn = inside.has(sourceId);
+        const dIn = inside.has(destinationId);
+        if (sIn === dIn)
+            continue;
+        const product = {
+            id: m.product.id,
+            name: m.product.name,
+            uom: m.product.uom?.name ?? '',
+        };
+        const at = dIn ? destinationId : sourceId;
+        const r = rowOf(product, { id: at, name: names.get(at) ?? '' });
+        const qty = m.productQty ?? m.quantity;
+        if (dIn)
+            r.incoming = r.incoming.plus(qty);
+        else
+            r.outgoing = r.outgoing.plus(qty);
+    }
+    return [...rows.values()]
+        .map((r) => ({ ...r, available: r.onHand.minus(r.reserved) }))
+        .filter((r) => !r.onHand.eq(0) || !r.incoming.eq(0) || !r.outgoing.eq(0))
+        .sort((a, b) => a.product.name.localeCompare(b.product.name) ||
+        a.location.name.localeCompare(b.location.name));
+}
+function dayBefore(day) {
+    const d = new Date(`${day}T00:00:00`);
+    d.setDate(d.getDate() - 1);
+    return d;
+}
+// ---------------------------------------------------------------------------------------------------- HTTP
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+const ints = (v) => typeof v === 'string' && v !== ''
+    ? v
+        .split(',')
+        .map((x) => Number(x))
+        .filter((n) => Number.isInteger(n) && n > 0)
+    : [];
+const money = (d) => d.toFixed(2);
+const qtyText = (d) => d.toFixed(3);
+const esc = (s) => s.replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[c]);
+const isDecimal = (v) => typeof v === 'object' && v !== null && typeof v.toFixed === 'function';
+/** The table of a report as rows of cells (the first the header), for XLSX and PDF. */
+function tableOf(kind, data) {
+    if (kind === 'summary') {
+        const head = ['Product', 'Unit', 'Opening'];
+        for (const t of IN_TYPES)
+            head.push(TYPE_LABELS[t]);
+        head.push('Total in');
+        for (const t of OUT_TYPES)
+            head.push(TYPE_LABELS[t]);
+        head.push('Total out', 'Closing');
+        if (data.valued)
+            head.push('Opening value', 'Value in', 'Value out', 'Closing value');
+        return [
+            head,
+            ...data.rows.map((r) => {
+                const row = [r.product.name, r.product.uom, r.opening.qty];
+                for (const t of IN_TYPES)
+                    row.push(r.in[t].qty);
+                row.push(r.totalIn.qty);
+                for (const t of OUT_TYPES)
+                    row.push(r.out[t].qty);
+                row.push(r.totalOut.qty, r.closing.qty);
+                if (data.valued)
+                    row.push(r.opening.value, r.totalIn.value, r.totalOut.value, r.closing.value);
+                return row;
+            }),
+        ];
+    }
+    if (kind === 'details')
+        return [
+            [
+                'Date',
+                'Reference',
+                'Source document',
+                'Product',
+                'Unit',
+                'From',
+                'To',
+                'Movement',
+                'Quantity',
+                ...(data.valued ? ['Value'] : []),
+            ],
+            ...data.rows.map((r) => [
+                r.date,
+                r.reference,
+                r.origin ?? '',
+                r.product.name,
+                r.product.uom,
+                r.from,
+                r.to,
+                TYPE_LABELS[r.type],
+                r.qty,
+                ...(data.valued ? [r.value] : []),
+            ]),
+        ];
+    return [
+        ['Product', 'Unit', 'Location', 'On hand', 'Reserved', 'Available', 'Incoming', 'Outgoing'],
+        ...data.rows.map((r) => [
+            r.product.name,
+            r.product.uom,
+            r.location.name,
+            r.onHand,
+            r.reserved,
+            r.available,
+            r.incoming,
+            r.outgoing,
+        ]),
+    ];
+}
+function sheetOf(name, rows, currency) {
+    const format = moneyFormat(currency);
+    const valueColumns = new Set((rows[0] ?? []).map((h, i) => (String(h).toLowerCase().includes('value') ? i : -1)));
+    return {
+        name,
+        rows: rows.map((r, i) => r.map((v, j) => {
+            if (isDecimal(v))
+                return valueColumns.has(j) ? { decimal: money(v), format } : Number(qtyText(v));
+            return i === 0 ? { text: String(v), bold: true } : String(v);
+        })),
+        headerRows: 1,
+        widths: (rows[0] ?? []).map((h, i) => i === 0 ? 32 : Math.max(10, Math.min(18, String(h).length + 2))),
+    };
+}
+function htmlOf(title, subtitle, rows, locale) {
+    const number = new Intl.NumberFormat(locale, { maximumFractionDigits: 3 });
+    const cell = (v, tag) => isDecimal(v)
+        ? `<${tag} class="n">${number.format(Number(v.toFixed(3)))}</${tag}>`
+        : `<${tag}>${esc(v)}</${tag}>`;
+    const [head, ...body] = rows;
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${esc(title)}</title><style>
+body { font: 8pt system-ui, sans-serif; color: #111; }
+h1 { font-size: 13pt; margin: 0 0 2mm; } p { margin: 0 0 4mm; }
+table { width: 100%; border-collapse: collapse; }
+th, td { border-bottom: 1px solid #ccc; padding: 1mm 1.2mm; text-align: start; vertical-align: top; }
+th { background: #f2f2f2; } .n { text-align: end; white-space: nowrap; }
+</style></head><body><h1>${esc(title)}</h1><p>${esc(subtitle)}</p><table><thead><tr>${(head ?? [])
+        .map((v) => cell(v, 'th'))
+        .join('')}</tr></thead><tbody>${body
+        .map((r) => `<tr>${r.map((v) => cell(v, 'td')).join('')}</tr>`)
+        .join('')}</tbody></table></body></html>`;
+}
+const figureJson = (f) => ({ qty: qtyText(f.qty), value: money(f.value) });
+export function registerLedgerRoutes(context) {
+    const { app } = context;
+    const scopeOf = (query) => ({
+        warehouses: ints(query['warehouses']),
+        locations: ints(query['locations']),
+        categories: ints(query['categories']),
+        products: ints(query['products']),
+    });
+    const serve = async (request, reply, kind, filename, compute, json, subtitle) => {
+        const query = request.query;
+        const format = query['format'] === 'xlsx' || query['format'] === 'pdf' ? query['format'] : 'json';
+        const out = await request.env(async (raw) => {
+            const env = raw;
+            env.access.check('stock.move', format === 'json' ? 'read' : 'export');
+            const data = await compute(env);
+            if (format === 'json')
+                return { json: json(data) };
+            await audit(raw, {
+                kind: 'data.export',
+                summary: `Exported the stock ${kind === 'stock' ? 'report' : 'ledger'} as ${format}.`,
+                targetModel: 'stock.move',
+                details: { kind, query },
+                ip: request.ip,
+            });
+            const [company] = await env
+                .model('res.company')
+                .search({ where: { id: env.companyRef }, limit: 1 })
+                .then((c) => c.load({ currency: ['name'] }));
+            return {
+                rows: tableOf(kind, data),
+                company: {
+                    name: company?.name ?? '',
+                    currency: company?.currency.name ?? 'BDT',
+                    locale: company?.numberGrouping === 'lakh' ? 'en-IN' : 'en-US',
+                },
+            };
+        }, { write: format !== 'json' });
+        if ('json' in out)
+            return out.json;
+        const title = kind === 'stock' ? 'Stock report' : 'Stock ledger';
+        const content = format === 'xlsx'
+            ? workbook([sheetOf(title, out.rows, out.company.currency)])
+            : await renderPdf(htmlOf(title, `${out.company.name} · ${subtitle}`, out.rows, out.company.locale), {
+                paper: 'A4',
+                orientation: 'landscape',
+                blocks: [],
+            });
+        await reply
+            .type(format === 'xlsx'
+            ? 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            : 'application/pdf')
+            .header('content-disposition', `attachment; filename="${filename}.${format}"`)
+            .send(content);
+        return reply;
+    };
+    app.get('/api/v1/stockroom/ledger', async (request, reply) => {
+        const query = request.query;
+        const from = typeof query['from'] === 'string' ? query['from'] : '';
+        const to = typeof query['to'] === 'string' ? query['to'] : '';
+        if (!DAY.test(from) || !DAY.test(to) || from > to)
+            throw new HttpProblem(400, 'invalid-period', 'Invalid period', 'Give from and to as YYYY-MM-DD, from first.');
+        const mode = query['mode'] === 'details' ? 'details' : 'summary';
+        const scope = scopeOf(query);
+        return serve(request, reply, mode, `stock-ledger-${from}-${to}`, (env) => mode === 'details'
+            ? ledgerDetails(env, scope, from, to)
+            : ledgerSummary(env, scope, from, to), (data) => ({
+            valued: data.valued,
+            from,
+            to,
+            mode,
+            rows: mode === 'details'
+                ? data.rows.map((r) => ({
+                    ...r,
+                    qty: qtyText(r.qty),
+                    value: money(r.value),
+                }))
+                : data.rows.map((r) => ({
+                    product: r.product,
+                    opening: figureJson(r.opening),
+                    in: Object.fromEntries(IN_TYPES.map((t) => [t, figureJson(r.in[t])])),
+                    out: Object.fromEntries(OUT_TYPES.map((t) => [t, figureJson(r.out[t])])),
+                    totalIn: figureJson(r.totalIn),
+                    totalOut: figureJson(r.totalOut),
+                    closing: figureJson(r.closing),
+                })),
+        }), `${from} – ${to}`);
+    });
+    app.get('/api/v1/stockroom/stock', async (request, reply) => {
+        const query = request.query;
+        const scope = scopeOf(query);
+        return serve(request, reply, 'stock', 'stock-report', async (env) => ({ valued: false, rows: await stockReport(env, scope) }), (data) => ({
+            rows: data.rows.map((r) => ({
+                product: r.product,
+                location: r.location,
+                onHand: qtyText(r.onHand),
+                reserved: qtyText(r.reserved),
+                available: qtyText(r.available),
+                incoming: qtyText(r.incoming),
+                outgoing: qtyText(r.outgoing),
+            })),
+        }), isoDay(new Date()));
+    });
+}