shutro-erp 0.3.5 → 0.3.7

package/dist/stock/replenish.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Replenishment (RFC 0024 §2.6): each reorder rule's forecast in its warehouse — on hand in the warehouse's stock
+ * location and those inside it, less what confirmed transfers take out, plus what they bring in and what other apps
+ * have on order (`pending()`: requests for quotation, production orders) — and, below the minimum, what to order to
+ * reach the maximum, rounded up to the rule's step. Every figure is written on the rule with the reckoning in words,
+ * so the screen can say why it proposes what it does. Ordering goes through the rules' `procure()`, by method.
+ */
+import { type Decimal } from '../server/orm.js';
+import type { Env } from './.kosh/bindings.js';
+export interface Reckoning {
+    readonly onHand: Decimal;
+    readonly forecast: Decimal;
+    readonly proposed: Decimal;
+    readonly explanation: string;
+}
+/** The forecast and proposal of each rule of `ids` (or every active rule of the user's companies). */
+export declare function reckon(env: Env, ids?: readonly number[]): Promise<Map<number, Reckoning>>;
+/** Writes each rule's figures (those of `ids`, or every rule); returns how many were refreshed. */
+export declare function refreshRules(env: Env, ids?: readonly number[]): Promise<number>;
+export interface Ordered {
+    readonly ordered: {
+        rule: number;
+        document: string;
+        quantity: string;
+    }[];
+    readonly skipped: {
+        rule: number;
+        reason: string;
+    }[];
+}
+/**
+ * Orders the rules of `ids`: `quantities` where given, else what each proposes now. Rules with nothing to order are
+ * skipped with the reason; the others are ordered by their method, their last order written, their figures
+ * refreshed (what is now on order counts).
+ */
+export declare function orderRules(env: Env, ids: readonly number[], quantities?: ReadonlyMap<number, Decimal>): Promise<Ordered>;
+/** The rules to order on their own: automatic, not snoozed, with something to order once refreshed. */
+export declare function orderAutomatic(env: Env): Promise<Ordered>;

package/dist/stock/replenish.js

@@ -0,0 +1,191 @@
+/**
+ * Replenishment (RFC 0024 §2.6): each reorder rule's forecast in its warehouse — on hand in the warehouse's stock
+ * location and those inside it, less what confirmed transfers take out, plus what they bring in and what other apps
+ * have on order (`pending()`: requests for quotation, production orders) — and, below the minimum, what to order to
+ * reach the maximum, rounded up to the rule's step. Every figure is written on the rule with the reckoning in words,
+ * so the screen can say why it proposes what it does. Ordering goes through the rules' `procure()`, by method.
+ */
+import { orm } from '../server/orm.js';
+import { warehouseStock } from './module.js';
+const zero = orm.toDecimal(0);
+/** A quantity as people read it: `12`, `2.5`. */
+const n = (d) => d.toDecimalPlaces(4).toString();
+/** "12 (TR/2026/00004, TR/2026/00009)": the documents, the first three. */
+function withDocuments(quantity, documents) {
+    const unique = [...new Set(documents.filter((d) => d !== ''))];
+    if (unique.length === 0)
+        return n(quantity);
+    const shown = unique.slice(0, 3).join(', ');
+    return `${n(quantity)} (${shown}${unique.length > 3 ? ', …' : ''})`;
+}
+/** The forecast and proposal of each rule of `ids` (or every active rule of the user's companies). */
+export async function reckon(env, ids) {
+    const found = env
+        .model('stock.reorder')
+        .browse((ids ?? (await env.model('stock.reorder').search({})).ids));
+    const rules = await found.load({ product: true });
+    const pending = await found.pending();
+    const out = new Map();
+    const proposals = new Map();
+    for (const r of rules) {
+        const { root, inside } = await warehouseStock(env, r.warehouse.id, r.company.id);
+        if (root === null)
+            continue;
+        const quants = await (await env.model('stock.quant').search({
+            where: { product: r.product.id, location: { in: [...inside] } },
+        })).load(['quantity']);
+        const onHand = [...quants].reduce((s, q) => s.plus(q.quantity), zero);
+        const moves = await (await env.model('stock.move').search({
+            where: {
+                product: r.product.id,
+                'picking.state': 'confirmed',
+                or: [
+                    { 'picking.source': { in: [...inside] } },
+                    { 'picking.destination': { in: [...inside] } },
+                ],
+            },
+        })).load({ picking: true });
+        let outgoing = zero;
+        let incoming = zero;
+        const outDocs = [];
+        const inDocs = [];
+        for (const m of moves) {
+            const from = inside.has(m.picking.source.id);
+            const to = inside.has(m.picking.destination.id);
+            if (from === to)
+                continue; // inside the warehouse: neither in nor out
+            const qty = m.productQty ?? m.quantity;
+            if (from) {
+                outgoing = outgoing.plus(qty);
+                outDocs.push(m.picking.name);
+            }
+            else {
+                incoming = incoming.plus(qty);
+                inDocs.push(m.picking.name);
+            }
+        }
+        const onOrder = pending.get(r.id) ?? [];
+        const ordered = onOrder.reduce((s, p) => s.plus(orm.toDecimal(p.quantity)), zero);
+        const forecast = onHand.minus(outgoing).plus(incoming).plus(ordered);
+        let sum = `On hand ${n(onHand)}`;
+        if (outgoing.gt(0))
+            sum += ` − going out ${withDocuments(outgoing, outDocs)}`;
+        if (incoming.gt(0))
+            sum += ` + coming in ${withDocuments(incoming, inDocs)}`;
+        if (ordered.gt(0))
+            sum += ` + on order ${withDocuments(ordered, onOrder.map((p) => p.document))}`;
+        let proposed = zero;
+        let verdict;
+        if (r.trigger === 'order')
+            verdict =
+                r.method === 'dropship'
+                    ? 'dropshipped: the vendor delivers each order to the customer'
+                    : 'ordered for each delivery (make to order)';
+        else if (forecast.lt(r.minimum)) {
+            const need = r.maximum.minus(forecast);
+            proposed = need.div(r.multiple).ceil().times(r.multiple);
+            verdict = `below the minimum ${n(r.minimum)}: ${n(need)} to reach the maximum ${n(r.maximum)}`;
+            if (!proposed.eq(need))
+                verdict += `, ordered in steps of ${n(r.multiple)}: ${n(proposed)}`;
+        }
+        else
+            verdict = `not below the minimum ${n(r.minimum)}: nothing to order`;
+        out.set(r.id, {
+            onHand,
+            forecast,
+            proposed,
+            explanation: `${sum} = forecast ${n(forecast)}; ${verdict}.`,
+        });
+        if (proposed.gt(0))
+            proposals.set(r.id, proposed.toString());
+    }
+    // Where it would come from (a bridge says: the vendor and why).
+    if (proposals.size > 0) {
+        const sources = await env
+            .model('stock.reorder')
+            .browse([...proposals.keys()])
+            .sourcing(proposals);
+        for (const [id, text] of sources) {
+            const r = out.get(id);
+            if (r !== undefined && text !== '')
+                out.set(id, { ...r, explanation: `${r.explanation} ${text}` });
+        }
+    }
+    return out;
+}
+/** Writes each rule's figures (those of `ids`, or every rule); returns how many were refreshed. */
+export async function refreshRules(env, ids) {
+    const figures = await reckon(env, ids);
+    const now = new Date();
+    for (const [id, f] of figures)
+        await env
+            .model('stock.reorder')
+            .browse([id])
+            .write({
+            onHand: f.onHand,
+            forecast: f.forecast,
+            proposed: f.proposed,
+            explanation: f.explanation,
+            refreshedAt: now,
+        });
+    await env.flush();
+    return figures.size;
+}
+const NO_APP = {
+    buy: 'Buying needs Purchase with receipts (purchase_stock) installed.',
+    make: 'Making needs Production (production) installed.',
+    transfer: 'The warehouses have no stock location.',
+};
+/**
+ * Orders the rules of `ids`: `quantities` where given, else what each proposes now. Rules with nothing to order are
+ * skipped with the reason; the others are ordered by their method, their last order written, their figures
+ * refreshed (what is now on order counts).
+ */
+export async function orderRules(env, ids, quantities = new Map()) {
+    const figures = await reckon(env, ids);
+    const wanted = new Map();
+    const skipped = [];
+    for (const id of ids) {
+        const qty = quantities.get(id) ?? figures.get(id)?.proposed ?? zero;
+        if (qty.gt(0))
+            wanted.set(id, qty);
+        else
+            skipped.push({
+                rule: id,
+                reason: 'Nothing to order: the forecast is not below the minimum.',
+            });
+    }
+    if (wanted.size === 0)
+        return { ordered: [], skipped };
+    const rules = env.model('stock.reorder').browse([...wanted.keys()]);
+    const made = await rules.procure(new Map([...wanted].map(([id, q]) => [id, q.toString()])));
+    const ordered = [];
+    for (const r of await rules.load({})) {
+        const document = made.get(r.id);
+        if (document === undefined) {
+            skipped.push({ rule: r.id, reason: NO_APP[r.method] ?? 'No app orders this method.' });
+            continue;
+        }
+        ordered.push({ rule: r.id, document, quantity: n(wanted.get(r.id) ?? zero) });
+        await env
+            .model('stock.reorder')
+            .browse([r.id])
+            .write({ lastOrder: document });
+    }
+    await env.flush();
+    await refreshRules(env, ordered.map((o) => o.rule));
+    return { ordered, skipped };
+}
+/** The rules to order on their own: automatic, not snoozed, with something to order once refreshed. */
+export async function orderAutomatic(env) {
+    await refreshRules(env);
+    const today = env.today();
+    const due = await env.model('stock.reorder').search({
+        where: {
+            auto: true,
+            proposed: { gt: 0 },
+            or: [{ snoozedUntil: { isNull: true } }, { snoozedUntil: { lt: today } }],
+        },
+    });
+    return due.length === 0 ? { ordered: [], skipped: [] } : orderRules(env, due.ids);
+}

package/dist/stock/returns.d.ts

@@ -0,0 +1,157 @@
+import { type Env } from './.kosh/bindings.js';
+/** Why goods come back: reported by product and partner. */
+export declare const StockReturnReason: import("../server/orm.js").Model<"stock.return.reason", {
+    readonly id: import("../server/orm.js").IdField<"stock.return.reason">;
+    readonly createdAt: import("../server/orm.js").ScalarField<'datetime', Date, Date, {
+        required: true;
+        readonly: true;
+        computed: false;
+        inverse: false;
+        hasDefault: false;
+        sequence: false;
+    }>;
+    readonly updatedAt: import("../server/orm.js").ScalarField<'datetime', Date, Date, {
+        required: true;
+        readonly: true;
+        computed: false;
+        inverse: false;
+        hasDefault: false;
+        sequence: false;
+    }>;
+    readonly createdBy: import("../server/orm.js").Many2oneField<'res.users', {
+        required: false;
+        readonly: true;
+        computed: false;
+        inverse: false;
+        hasDefault: false;
+        sequence: false;
+    }>;
+    readonly updatedBy: import("../server/orm.js").Many2oneField<'res.users', {
+        required: false;
+        readonly: true;
+        computed: false;
+        inverse: false;
+        hasDefault: false;
+        sequence: false;
+    }>;
+    readonly displayName: import("../server/orm.js").CharField<{
+        required: true;
+        readonly: true;
+        computed: true;
+        inverse: false;
+        hasDefault: false;
+        sequence: false;
+    }>;
+    readonly active: import("../server/orm.js").ActiveField;
+    readonly name: import("../server/orm.js").CharField<{
+        readonly required: true;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string | Readonly<Record<string, string>>>;
+    readonly sequence: import("../server/orm.js").ScalarField<"integer", number, number, {
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: true;
+        readonly readonly: false;
+    }>;
+    readonly code: import("../server/orm.js").CharField<{
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string>;
+}, {} & import("../server/orm.js").TransitionMethods<{
+    readonly name: import("../server/orm.js").CharField<{
+        readonly required: true;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string | Readonly<Record<string, string>>>;
+    readonly sequence: import("../server/orm.js").ScalarField<"integer", number, number, {
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: true;
+        readonly readonly: false;
+    }>;
+    readonly code: import("../server/orm.js").CharField<{
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string>;
+}>>;
+/** The reasons a database starts with. */
+export declare const DEFAULT_RETURN_REASONS: readonly [{
+    readonly code: 'damaged';
+    readonly en: 'Damaged';
+    readonly bn: 'ক্ষতিগ্রস্ত';
+}, {
+    readonly code: 'wrong_item';
+    readonly en: 'Wrong item';
+    readonly bn: 'ভুল পণ্য';
+}, {
+    readonly code: 'not_as_ordered';
+    readonly en: 'Not as ordered';
+    readonly bn: 'অর্ডার অনুযায়ী নয়';
+}, {
+    readonly code: 'surplus';
+    readonly en: 'Surplus';
+    readonly bn: 'অতিরিক্ত';
+}, {
+    readonly code: 'quality';
+    readonly en: 'Quality';
+    readonly bn: 'মানের সমস্যা';
+}];
+export declare function installReturnReasons(env: Env): Promise<number>;
+/** What each line of a done transfer can still return. */
+export interface Returnable {
+    readonly move: number;
+    readonly product: number;
+    readonly name: string;
+    readonly done: string;
+    readonly returned: string;
+    readonly returnable: string;
+}
+/** The lines of a done delivery or receipt with what is left to return (in the product's unit). */
+export declare function returnableLines(env: Env, pickingId: number): Promise<Returnable[]>;
+/**
+ * Makes and confirms the return of `lines` (move and quantity, in the product's unit) with a reason; `location`
+ * receives it instead of where the goods came from (a damaged-goods location). Returns the new transfer.
+ */
+export declare function createReturn(env: Env, pickingId: number, input: {
+    readonly lines: readonly {
+        readonly move: number;
+        readonly quantity: string;
+    }[];
+    readonly reason: number;
+    readonly note?: string | null;
+    readonly location?: number | null;
+}): Promise<{
+    picking: number;
+    name: string;
+}>;

package/dist/stock/returns.js

@@ -0,0 +1,163 @@
+/**
+ * Returns (RFC 0030 §3.2). A done delivery or receipt can be returned, in part: each line up to what was done and
+ * not returned yet (returns in progress count), with a reason. The return is a transfer of the other way — a
+ * customer's goods back in, goods back to the vendor —, linked to the original (`returnOf`) and line by line, with
+ * the original's links carried (an order's, through `backorderValues`), and lots taken back from the original's.
+ * It is confirmed, and validated like any transfer; `stock_account` values it at the original cost.
+ */
+import { HttpProblem } from '../server/index.js';
+import { orm } from '../server/orm.js';
+import { defineModel, f } from './.kosh/bindings.js';
+const ALL = ['read', 'write', 'create', 'unlink', 'export', 'import'];
+const zero = orm.toDecimal('0');
+/** Why goods come back: reported by product and partner. */
+export const StockReturnReason = defineModel('stock.return.reason', {
+    label: 'Return reason',
+    archivable: true,
+    order: ['sequence asc', 'id asc'],
+    access: { 'stock.user': ['read'], 'stock.manager': ALL },
+    fields: {
+        name: f.char({ required: true, translate: true, label: 'Reason' }),
+        sequence: f.integer({ default: 10 }),
+        code: f.char({ index: 'unique', label: 'Code' }),
+    },
+});
+/** The reasons a database starts with. */
+export const DEFAULT_RETURN_REASONS = [
+    { code: 'damaged', en: 'Damaged', bn: 'ক্ষতিগ্রস্ত' },
+    { code: 'wrong_item', en: 'Wrong item', bn: 'ভুল পণ্য' },
+    { code: 'not_as_ordered', en: 'Not as ordered', bn: 'অর্ডার অনুযায়ী নয়' },
+    { code: 'surplus', en: 'Surplus', bn: 'অতিরিক্ত' },
+    { code: 'quality', en: 'Quality', bn: 'মানের সমস্যা' },
+];
+export async function installReturnReasons(env) {
+    let made = 0;
+    const model = env.withFlags({ activeTest: false }).model('stock.return.reason');
+    for (const [i, r] of DEFAULT_RETURN_REASONS.entries()) {
+        if ((await model.search({ where: { code: r.code } })).ids.length > 0)
+            continue;
+        await model.create([
+            { code: r.code, name: { en_US: r.en, bn_BD: r.bn }, sequence: (i + 1) * 10 },
+        ]);
+        made++;
+    }
+    return made;
+}
+const OTHER_WAY = {
+    delivery: 'receipt',
+    receipt: 'delivery',
+};
+async function loadDone(env, pickingId) {
+    const [picking] = await env
+        .model('stock.picking')
+        .browse([pickingId])
+        .load({
+        moves: { product: true, returns: { picking: true } },
+        source: true,
+        destination: true,
+    });
+    if (picking === undefined)
+        throw new HttpProblem(404, 'missing-record', 'Not found', 'No such transfer.');
+    if (picking.state !== 'done')
+        throw new HttpProblem(409, 'not-done', 'Not done', 'Only a done transfer can be returned.');
+    if (OTHER_WAY[picking.kind] === undefined)
+        throw new HttpProblem(409, 'not-returnable', 'Not returnable', 'Deliveries and receipts are returned; other transfers are moved back by hand.');
+    return picking;
+}
+/** The lines of a done delivery or receipt with what is left to return (in the product's unit). */
+export async function returnableLines(env, pickingId) {
+    const picking = await loadDone(env, pickingId);
+    return [...picking.moves].map((m) => {
+        const done = m.doneQty ?? zero;
+        const returned = [...m.returns]
+            .filter((r) => r.picking.state !== 'cancel')
+            .reduce((s, r) => s.plus(r.quantity), zero);
+        const left = done.minus(returned);
+        return {
+            move: m.id,
+            product: m.product.id,
+            name: String(m.name ?? m.product.name),
+            done: done.toString(),
+            returned: returned.toString(),
+            returnable: (left.gt(0) ? left : zero).toString(),
+        };
+    });
+}
+/**
+ * Makes and confirms the return of `lines` (move and quantity, in the product's unit) with a reason; `location`
+ * receives it instead of where the goods came from (a damaged-goods location). Returns the new transfer.
+ */
+export async function createReturn(env, pickingId, input) {
+    const picking = await loadDone(env, pickingId);
+    const left = new Map((await returnableLines(env, pickingId)).map((l) => [l.move, l]));
+    const wanted = input.lines
+        .map((l) => ({ move: l.move, quantity: orm.toDecimal(l.quantity || '0') }))
+        .filter((l) => l.quantity.gt(0));
+    if (wanted.length === 0)
+        throw new HttpProblem(400, 'invalid-body', 'Nothing to return', 'Give a quantity to return.');
+    for (const w of wanted) {
+        const l = left.get(w.move);
+        if (l === undefined)
+            throw new HttpProblem(400, 'invalid-body', 'Unknown line', 'A line of this transfer.');
+        if (w.quantity.gt(orm.toDecimal(l.returnable)))
+            throw new HttpProblem(409, 'too-much', 'More than can be returned', `${l.name}: ${l.returnable} can still be returned.`);
+    }
+    const [reason] = await env
+        .model('stock.return.reason')
+        .browse([input.reason])
+        .load(['name']);
+    if (reason === undefined)
+        throw new HttpProblem(400, 'invalid-body', 'Reason required', 'Give the reason of the return.');
+    // The original's links (an order's) carried, the way reversed.
+    const base = (await env
+        .model('stock.picking')
+        .browse([pickingId])
+        .backorderValues()).get(pickingId) ?? {};
+    const moveValues = await env
+        .model('stock.move')
+        .browse(wanted.map((w) => w.move))
+        .backorderValues();
+    const made = await env.model('stock.picking').create([
+        {
+            ...base,
+            kind: OTHER_WAY[picking.kind],
+            source: picking.destination.id,
+            destination: input.location ?? picking.source.id,
+            origin: `Return of ${picking.name}`,
+            scheduledDate: env.today(),
+            next: null,
+            returnOf: picking.id,
+            returnReason: input.reason,
+            ...(input.note == null || input.note.trim() === '' ? {} : { note: input.note.trim() }),
+            moves: {
+                create: wanted.map((w) => ({
+                    ...(moveValues.get(w.move) ?? {}),
+                    // In the product's unit: what was done is counted that way.
+                    uom: [...picking.moves].find((m) => m.id === w.move)?.product.uom?.id ?? null,
+                    quantity: w.quantity.toString(),
+                    returnOf: w.move,
+                })),
+            },
+        },
+    ]);
+    const id = made.ids[0];
+    // The lots taken back are the original's, as far as the quantities go.
+    const lots = await (await env.model('stock.lot.line').search({ where: { picking: pickingId } })).load({ product: true, lot: true });
+    const rows = [];
+    for (const w of wanted) {
+        const product = [...picking.moves].find((m) => m.id === w.move)?.product.id;
+        let rest = w.quantity;
+        for (const l of lots) {
+            if (rest.lte(0) || l.product.id !== product || l.lot === null)
+                continue;
+            const take = rest.lt(l.quantity) ? rest : l.quantity;
+            rows.push({ picking: id, product, lot: l.lot.id, quantity: take.toString() });
+            rest = rest.minus(take);
+        }
+    }
+    if (rows.length > 0)
+        await env.model('stock.lot.line').create(rows);
+    await made.confirm();
+    const [row] = await made.load(['name']);
+    return { picking: id, name: String(row?.name ?? '') };
+}

package/dist/stock/web/Ledger.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Stockroom › Stock ledger (RFC 0032 §3.3): for a period and the chosen warehouses (or every one), each product's
+ * opening, what came in and went out by movement type, and its closing — as a summary or every movement —, and the
+ * stock report (on hand, reserved, available, incoming, outgoing per product and location), as the server computes
+ * them, with their XLSX and PDF files.
+ */
+import { type PageProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function Ledger({ api }: PageProps): ReactElement;