shutro-erp 0.3.3 → 0.3.5

package/dist/purchase_stock/module.js

@@ -0,0 +1,144 @@
+/**
+ * The data layer of the Purchase ↔ Stockroom bridge (RFC 0021): a confirmed purchase order gets its receipt — one
+ * Stockroom transfer with a line per goods line, in the line's unit, from the vendors into the company's main
+ * warehouse, expected on the order's arrival date — made once through the outbox (`purchase.order.confirmed`) and
+ * confirmed. The order shows its receipts and what is received; each line, its received quantity.
+ */
+import { productShutro } from '../product/index.js';
+import { purchaseShutro } from '../purchase/index.js';
+import { orm } from '../server/orm.js';
+import { defaultLocations, stockShutro } from '../stock/index.js';
+import { compute, defineModule, extendModel, f } from './.kosh/bindings.js';
+const zero = orm.toDecimal(0);
+export const PickingPurchase = extendModel('stock.picking', {
+    fields: {
+        purchaseOrder: f.many2one('purchase.order', { ondelete: 'set null', label: 'Purchase order' }),
+    },
+    overrides: {
+        // A backorder stays with its order.
+        backorderValues: async function (next) {
+            const out = await next();
+            for (const p of await this.load({}))
+                out.set(p.id, { ...out.get(p.id), purchaseOrder: p.purchaseOrder?.id ?? null });
+            return out;
+        },
+    },
+});
+export const MovePurchase = extendModel('stock.move', {
+    fields: {
+        purchaseLine: f.many2one('purchase.order.line', { ondelete: 'set null', label: 'Order line' }),
+    },
+    overrides: {
+        // The rest of a line stays tied to its order line.
+        backorderValues: async function (next) {
+            const out = await next();
+            for (const m of await this.load({}))
+                out.set(m.id, { ...out.get(m.id), purchaseLine: m.purchaseLine?.id ?? null });
+            return out;
+        },
+    },
+});
+export const LineReceived = extendModel('purchase.order.line', {
+    fields: {
+        moves: f.one2many('stock.move', 'purchaseLine'),
+        /** Received by validated receipts, in the line's unit. */
+        qtyReceived: f.decimal({
+            scale: 3,
+            store: true,
+            label: 'Received',
+            ...compute('purchase.order.line', 'qtyReceived', ['moves.quantity', 'moves.quantityDone', 'moves.picking.state'], (lines) => {
+                for (const l of lines)
+                    l.qtyReceived = [...l.moves]
+                        .filter((m) => m.picking.state === 'done')
+                        .reduce((s, m) => s.plus(m.quantityDone ?? m.quantity), zero);
+            }),
+        }),
+    },
+});
+export const OrderReceipts = extendModel('purchase.order', {
+    fields: {
+        receipts: f.one2many('stock.picking', 'purchaseOrder'),
+        receiptState: f.selection({
+            nothing: 'Nothing to receive',
+            to_receive: 'To receive',
+            partial: 'Partly received',
+            received: 'Received',
+        }, {
+            store: true,
+            label: 'Receipt',
+            ...compute('purchase.order', 'receiptState', ['state', 'lines.quantity', 'lines.qtyReceived', 'lines.product.kind'], (orders) => {
+                for (const o of orders) {
+                    const goods = [...o.lines].filter((l) => l.product.kind === 'goods');
+                    if (goods.length === 0 || (o.state !== 'purchase' && o.state !== 'done')) {
+                        o.receiptState = 'nothing';
+                        continue;
+                    }
+                    const done = goods.every((l) => (l.qtyReceived ?? zero).gte(l.quantity));
+                    const some = goods.some((l) => (l.qtyReceived ?? zero).gt(0));
+                    o.receiptState = done ? 'received' : some ? 'partial' : 'to_receive';
+                }
+            }),
+        }),
+    },
+});
+/**
+ * Makes and confirms the receipt of a confirmed order's goods lines, once (an order with a receipt that is not
+ * cancelled gets no other). Runs in an audited superuser scope: the buyer who confirmed needs no Stockroom rights
+ * for the warehouse to expect the goods. Returns the receipt, or null when there is nothing to receive.
+ */
+export async function createReceiptFor(env, orderId) {
+    return env.asSuperuser({ reason: 'receipt for a confirmed purchase order' }, async (su) => {
+        const [order] = await su
+            .model('purchase.order')
+            .browse([orm.asId(orderId, 'purchase.order')])
+            .load({ lines: { product: true, uom: true }, partner: true, company: true, receipts: true });
+        if (order === undefined || (order.state !== 'purchase' && order.state !== 'done'))
+            return null;
+        if ([...order.receipts].some((r) => r.state !== 'cancel'))
+            return null;
+        const goods = order.lines.filter((l) => l.product.kind === 'goods');
+        if (goods.length === 0)
+            return null;
+        const places = await defaultLocations(su, 'receipt', null, order.company.id);
+        if (places.source === null || places.destination === null)
+            throw new orm.ValidationError('purchase.order', ['state'], `The company of ${order.name} has no warehouse to receive into.`, 'Add a warehouse in Stockroom › Configuration › Warehouses.');
+        const made = await su.model('stock.picking').create([
+            {
+                kind: 'receipt',
+                partner: order.partner.id,
+                company: order.company.id,
+                warehouse: places.warehouse,
+                source: places.source,
+                destination: places.destination,
+                origin: order.name,
+                purchaseOrder: order.id,
+                ...(order.datePlanned === null ? {} : { scheduledDate: order.datePlanned }),
+                moves: {
+                    create: goods.map((l) => ({
+                        product: l.product.id,
+                        name: l.name,
+                        quantity: l.quantity,
+                        uom: l.uom?.id ?? null,
+                        purchaseLine: l.id,
+                    })),
+                },
+            },
+        ]);
+        await made.confirm();
+        return made.ids[0] ?? null;
+    });
+}
+export const purchaseStockShutro = defineModule({
+    name: 'purchase_stock',
+    version: '0.1.0',
+    depends: [purchaseShutro, stockShutro, productShutro],
+    groups: [
+        orm.defineGroup({
+            code: 'purchase_stock.user',
+            label: 'Purchase with receipts',
+            implies: ['purchase.user', 'stock.user'],
+        }),
+    ],
+    models: [],
+    extensions: [PickingPurchase, MovePurchase, LineReceived, OrderReceipts],
+});

package/dist/purchase_stock_account/.kosh/bindings.d.ts

@@ -0,0 +1,22 @@
+export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
+import { type DefinitionHelpers } from '../../server/orm.js';
+import type { DefaultLoaded, Env as CoreEnv, RecordSet as CoreRecordSet, Shutro as CoreShutro } from '../../server/orm.js';
+import type { SchemaView } from './schema.js';
+export type { SchemaView };
+/** Every model visible in this view. */
+export type ModelName = keyof SchemaView & string;
+/** `Env` typed to this view. */
+export type Env = CoreEnv<SchemaView>;
+/** `Shutro` typed to this view. */
+export type Shutro = CoreShutro<SchemaView>;
+/** A recordset of `M`, with the default loaded shape unless `L` is given. */
+export type Records<M extends ModelName, L = DefaultLoaded<SchemaView, M>> = CoreRecordSet<SchemaView, M, L>;
+export declare const compute: DefinitionHelpers<SchemaView>['compute'];
+export declare const check: DefinitionHelpers<SchemaView>['check'];
+export declare const onchange: DefinitionHelpers<SchemaView>['onchange'];
+export declare const records: DefinitionHelpers<SchemaView>['records'];
+export declare const method: DefinitionHelpers<SchemaView>['method'];
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export declare const record: DefinitionHelpers<SchemaView>['record'];
+export declare const override: DefinitionHelpers<SchemaView>['override'];
+export declare const ref: DefinitionHelpers<SchemaView>['ref'];

package/dist/purchase_stock_account/.kosh/bindings.js

@@ -0,0 +1,15 @@
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: affe9e70bc2ae97c
+// Bindings of module `purchase_stock_account`: 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';
+/** Definition callbacks typed against this module's view: no casts in computes, checks, onchange, methods. */
+const helpers = definitions();
+export const compute = helpers.compute;
+export const check = helpers.check;
+export const onchange = helpers.onchange;
+export const records = helpers.records;
+export const method = helpers.method;
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export const record = helpers.record;
+export const override = helpers.override;
+export const ref = helpers.ref;