shutro-erp 0.3.6 → 0.3.7

package/dist/indent_purchase/module.js

@@ -0,0 +1,163 @@
+/**
+ * The Requests ↔ Purchase bridge (RFC 0032 §3.4): what an approved indent asks for beyond what the store holds —
+ * and beyond what Purchase is already asked for — becomes a **purchase request**, one per indent with its lines
+ * linked, drafted for the requester to submit; the indent shows what is being bought and the purchase request where
+ * it came from. Proposed whenever both apps are installed.
+ */
+import { indentShutro } from '../indent/index.js';
+import { purchaseShutro } from '../purchase/index.js';
+import { orm } from '../server/orm.js';
+import { defaultLocations, onHandIn, stockShutro } from '../stock/index.js';
+import { compute, defineModule, extendModel, f, records } from './.kosh/bindings.js';
+const zero = orm.toDecimal(0);
+export const IndentLineBuying = extendModel('indent.request.line', {
+    fields: {
+        purchaseLines: f.one2many('purchase.request.line', 'indentLine', {
+            label: 'Purchase request lines',
+        }),
+        qtyBuying: f.decimal({
+            scale: 3,
+            store: true,
+            label: 'Being bought',
+            help: 'Asked of Purchase for this line, on purchase requests not cancelled.',
+            ...compute('indent.request.line', 'qtyBuying', ['purchaseLines.quantity', 'purchaseLines.status'], (lines) => {
+                for (const l of lines)
+                    l.qtyBuying = [...l.purchaseLines]
+                        .filter((p) => p.status !== 'cancelled')
+                        .reduce((s, p) => s.plus(p.quantity), zero);
+            }),
+        }),
+    },
+});
+/**
+ * What each line of an indent still owes beyond the store's stock and what Purchase is already asked for: the
+ * lines with a shortfall and its quantity.
+ */
+async function shortfalls(env, id) {
+    const [r] = await env
+        .model('indent.request')
+        .browse([id])
+        .load({ lines: { product: true, uom: true }, warehouse: true, company: true });
+    if (r === undefined)
+        return null;
+    const places = await defaultLocations(env, 'internal', r.warehouse.id, r.company.id);
+    const lines = [];
+    for (const l of r.lines) {
+        const held = places.source === null ? zero : await onHandIn(env, l.product.id, places.source);
+        const left = (l.qtyRemaining ?? zero).minus(held).minus(l.qtyBuying ?? zero);
+        if (left.gt(0))
+            lines.push({
+                product: { id: l.product.id, name: l.product.name },
+                uom: l.uom === null ? null : { id: l.uom.id },
+                id: l.id,
+                qty: left,
+            });
+    }
+    return {
+        request: {
+            id: r.id,
+            name: r.name,
+            purpose: r.purpose ?? null,
+            requester: { id: r.requester.id },
+            company: { id: r.company.id },
+            dateRequired: r.dateRequired,
+            priority: r.priority,
+        },
+        lines,
+    };
+}
+/** Drafts the purchase request of an indent's shortfall, as the system: the store keeper need not be a requester. */
+async function requestPurchase(env, id) {
+    await env.asSuperuser({ reason: 'purchase request for an indent' }, async (su) => {
+        const found = await shortfalls(su, id);
+        if (found === null || found.lines.length === 0)
+            return;
+        const r = found.request;
+        await su.model('purchase.request').create([
+            {
+                requester: r.requester.id,
+                company: r.company.id,
+                dateRequired: r.dateRequired,
+                priority: r.priority,
+                purpose: `${r.name}${r.purpose === null || r.purpose === '' ? '' : `: ${r.purpose}`}`,
+                indent: r.id,
+                lines: {
+                    create: found.lines.map((l) => ({
+                        product: l.product.id,
+                        name: l.product.name,
+                        uom: l.uom?.id ?? null,
+                        quantity: l.qty,
+                        dateRequired: r.dateRequired,
+                        indentLine: l.id,
+                    })),
+                },
+            },
+        ]);
+        await su.emit('indent.request.purchase_requested', { id: r.id });
+    });
+}
+export const IndentBuying = extendModel('indent.request', {
+    fields: {
+        purchaseRequests: f.one2many('purchase.request', 'indent', { label: 'Purchase requests' }),
+    },
+    fieldOverrides: {
+        state: {
+            transitionsAdd: {
+                /** What the store lacks goes to Purchase as a purchase request (RFC 0032 §3.4). */
+                buy: {
+                    from: ['approved'],
+                    to: 'approved',
+                    requires: 'indent_purchase.buy',
+                    guard: records('indent.request', async (requests) => {
+                        const env = requests.env;
+                        const out = [];
+                        for (const id of requests.ids) {
+                            const found = await shortfalls(env, id);
+                            if (found === null || found.lines.length === 0)
+                                out.push(id);
+                        }
+                        return out;
+                    }),
+                    message: 'The store holds enough for every line, or Purchase is asked already.',
+                    after: records('indent.request', async (requests) => {
+                        const env = requests.env;
+                        await env.flush();
+                        for (const id of requests.ids)
+                            await requestPurchase(env, id);
+                    }),
+                },
+            },
+        },
+    },
+});
+export const RequestFromIndent = extendModel('purchase.request', {
+    fields: {
+        indent: f.many2one('indent.request', { ondelete: 'set null', label: 'Indent' }),
+    },
+});
+export const RequestLineFromIndent = extendModel('purchase.request.line', {
+    fields: {
+        indentLine: f.many2one('indent.request.line', { ondelete: 'set null', label: 'Indent line' }),
+    },
+});
+export const indentPurchaseShutro = defineModule({
+    name: 'indent_purchase',
+    version: '0.1.0',
+    depends: [indentShutro, purchaseShutro, stockShutro],
+    groups: [
+        orm.defineGroup({
+            code: 'indent_purchase.user',
+            label: 'Requests with Purchase',
+            implies: ['indent.store', 'purchase.requester'],
+        }),
+    ],
+    permissions: [
+        orm.definePermission({
+            code: 'indent_purchase.buy',
+            label: 'Ask Purchase for what the store lacks',
+            groups: ['indent.store', 'indent_purchase.user'],
+        }),
+    ],
+    models: [],
+    extensions: [IndentLineBuying, IndentBuying, RequestFromIndent, RequestLineFromIndent],
+});

package/dist/l10n_bd/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 3b7c643d072efb3e
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: fa9d8ad9fe20dc54
 // Bindings of module `l10n_bd`: import the definition API from here to get types scoped to what it can see.
 export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
 import { definitions } from '../../server/orm.js';