shutro-erp 0.3.4 → 0.3.6

package/dist/mrp/module.js

@@ -0,0 +1,757 @@
+/**
+ * The data layer of Production (RFC 0021): bills of materials with versions and effective dates, work centres with
+ * their hours and cost, and production orders that say what is required, available and short before they start and
+ * what they will cost. Orders move stock only through Stockroom: Confirm reserves the components in a consumption
+ * transfer (stock → Production), Produce validates it and the output transfer (Production → stock).
+ */
+import { contactsShutro } from '../contacts/index.js';
+import { messagingShutro } from '../messaging/index.js';
+import { productShutro } from '../product/index.js';
+import { orm } from '../server/orm.js';
+import { defaultLocations, inProductUnit, stockShutro } from '../stock/index.js';
+import { check, compute, defineModel, defineModule, extendModel, f, onchange, records, } from './.kosh/bindings.js';
+const READ = ['read'];
+const ALL = ['read', 'write', 'create', 'unlink'];
+const zero = orm.toDecimal(0);
+const money = (d) => d.toDecimalPlaces(2);
+/** A date as `YYYY-MM-DD` (date-only values from PostgreSQL are local midnights: their local parts). */
+const iso = (v) => {
+    if (!(v instanceof Date))
+        return String(v ?? '');
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${v.getFullYear()}-${pad(v.getMonth() + 1)}-${pad(v.getDate())}`;
+};
+/** The bill of `product` valid on `date`: the latest that starts on or before it and has not ended. */
+export async function validBom(env, product, date) {
+    const bills = await (await env.model('mrp.bom').search({ where: { product } })).load([
+        'validFrom',
+        'validTo',
+    ]);
+    const valid = [...bills]
+        .filter((b) => (b.validFrom === null || iso(b.validFrom) <= date) &&
+        (b.validTo === null || iso(b.validTo) >= date))
+        .sort((a, b) => iso(b.validFrom).localeCompare(iso(a.validFrom)) || b.id - a.id);
+    return valid[0]?.id ?? null;
+}
+export const MrpWorkcenter = defineModel('mrp.workcenter', {
+    label: 'Work centre',
+    recName: 'name',
+    order: ['name asc'],
+    archivable: true,
+    companyScoped: { required: true },
+    access: { 'mrp.user': READ, 'mrp.manager': [...ALL, 'export', 'import'] },
+    fields: {
+        name: f.char({ required: true }),
+        code: f.char(),
+        /** Hours it works a day (its capacity). */
+        hoursPerDay: f.decimal({ scale: 2, required: true, default: '8', label: 'Hours a day' }),
+        /** Labour and overhead per hour of work. */
+        costPerHour: f.decimal({ scale: 2, required: true, default: '0', label: 'Cost per hour' }),
+        note: f.text(),
+    },
+    sqlConstraints: {
+        positive: {
+            check: orm.sql `hours_per_day > 0 AND cost_per_hour >= 0`,
+            message: 'A work centre works some hours a day, at a cost that is not negative.',
+        },
+    },
+});
+export const MrpBom = defineModel('mrp.bom', {
+    label: 'Bill of materials',
+    recName: 'label',
+    order: ['product asc', 'validFrom desc', 'id desc'],
+    archivable: true,
+    companyScoped: { required: true },
+    tracking: ['quantity', 'validFrom', 'validTo'],
+    access: { 'mrp.user': READ, 'mrp.manager': [...ALL, 'export', 'import'] },
+    fields: {
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        /** How many of the product one bill makes, in the product's unit. */
+        quantity: f.decimal({ scale: 4, required: true, default: '1', label: 'Makes' }),
+        version: f.char({ required: true, default: 'v1' }),
+        /** From when this version is used (empty: always). */
+        validFrom: f.date({ label: 'Valid from' }),
+        validTo: f.date({ label: 'Valid until' }),
+        lines: f.one2many('mrp.bom.line', 'bom', { label: 'Components' }),
+        operations: f.one2many('mrp.bom.operation', 'bom'),
+        byproducts: f.one2many('mrp.bom.byproduct', 'bom', { label: 'By-products' }),
+        note: f.text(),
+        label: f.char({
+            store: true,
+            label: 'Bill of materials',
+            ...compute('mrp.bom', 'label', ['product.name', 'version'], (bills) => {
+                for (const b of bills)
+                    b.label = `${b.product.name} ${b.version}`;
+            }),
+        }),
+    },
+    sqlConstraints: {
+        positive: { check: orm.sql `quantity > 0`, message: 'A bill makes a positive quantity.' },
+        period: {
+            check: orm.sql `valid_from IS NULL OR valid_to IS NULL OR valid_to >= valid_from`,
+            message: 'A bill ends on or after it starts.',
+        },
+    },
+});
+export const MrpBomLine = defineModel('mrp.bom.line', {
+    label: 'Component',
+    order: ['id asc'],
+    access: { 'mrp.user': READ, 'mrp.manager': ALL },
+    fields: {
+        bom: f.many2one('mrp.bom', { required: true, ondelete: 'cascade' }),
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        quantity: f.decimal({ scale: 4, required: true, default: '1' }),
+        uom: f.many2one('uom.uom', { label: 'Unit' }),
+    },
+    onchange: {
+        product: onchange('mrp.bom.line', async (d) => {
+            const p = await d.record('product');
+            if (p?.uom)
+                d.set('uom', p.uom.id);
+        }),
+    },
+    sqlConstraints: {
+        positive: {
+            check: orm.sql `quantity > 0`,
+            message: 'A component is needed in a positive quantity.',
+        },
+    },
+    constraints: {
+        notItself: {
+            ...check('mrp.bom.line', ['product', 'bom'], async (lines) => (await lines.load({ bom: true }))
+                .filter((l) => l.bom.product.id === l.product.id)
+                .map((l) => l.id)),
+            message: 'A product is not a component of itself.',
+        },
+    },
+});
+/** What else one bill makes (sawdust, offcuts), and the share of the order's cost it carries. */
+export const MrpBomByproduct = defineModel('mrp.bom.byproduct', {
+    label: 'By-product',
+    order: ['id asc'],
+    access: { 'mrp.user': READ, 'mrp.manager': ALL },
+    fields: {
+        bom: f.many2one('mrp.bom', { required: true, ondelete: 'cascade' }),
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        quantity: f.decimal({ scale: 4, required: true, default: '1' }),
+        uom: f.many2one('uom.uom', { label: 'Unit' }),
+        /** Percent of the order's cost (the main product carries the rest). */
+        costShare: f.decimal({
+            scale: 2,
+            required: true,
+            default: '0',
+            label: 'Share of the cost (%)',
+        }),
+    },
+    sqlConstraints: {
+        positive: {
+            check: orm.sql `quantity > 0 AND cost_share >= 0 AND cost_share < 100`,
+            message: 'A by-product is made in a positive quantity, with a share of the cost under 100 %.',
+        },
+    },
+    constraints: {
+        sharesUnderAll: {
+            ...check('mrp.bom.byproduct', ['costShare', 'bom', 'product'], async (lines) => {
+                const failing = [];
+                for (const l of await lines.load({ bom: { byproducts: true } })) {
+                    const total = [...l.bom.byproducts].reduce((s, b) => s.plus(b.costShare), zero);
+                    if (total.gte(100) || l.product.id === l.bom.product.id)
+                        failing.push(l.id);
+                }
+                return failing;
+            }),
+            message: 'By-products are other products than the one made, and their shares of the cost stay under 100 %.',
+        },
+    },
+});
+export const MrpBomOperation = defineModel('mrp.bom.operation', {
+    label: 'Operation',
+    order: ['id asc'],
+    access: { 'mrp.user': READ, 'mrp.manager': ALL },
+    fields: {
+        bom: f.many2one('mrp.bom', { required: true, ondelete: 'cascade' }),
+        name: f.char({ required: true }),
+        workcenter: f.many2one('mrp.workcenter', { required: true, ondelete: 'restrict' }),
+        /** Minutes for what one bill makes. */
+        minutes: f.decimal({ scale: 2, required: true, default: '0' }),
+    },
+});
+export const MrpProductionComponent = defineModel('mrp.production.component', {
+    label: 'Component need',
+    order: ['id asc'],
+    access: { 'mrp.user': READ, 'mrp.manager': READ },
+    fields: {
+        production: f.many2one('mrp.production', { required: true, ondelete: 'cascade' }),
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        /** In the product's unit. */
+        required: f.decimal({ scale: 4, required: true, default: '0' }),
+        /** Available in the warehouse when the order was last checked. */
+        available: f.decimal({ scale: 4, required: true, default: '0' }),
+        short: f.decimal({
+            scale: 4,
+            store: true,
+            label: 'Short',
+            ...compute('mrp.production.component', 'short', ['required', 'available'], (lines) => {
+                for (const l of lines) {
+                    const missing = l.required.minus(l.available);
+                    l.short = missing.gt(0) ? missing : zero;
+                }
+            }),
+        }),
+        cost: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Cost',
+            ...compute('mrp.production.component', 'cost', ['required', 'product.standardPrice'], (lines) => {
+                for (const l of lines)
+                    l.cost = money(l.required.times(l.product.standardPrice));
+            }),
+        }),
+    },
+});
+/**
+ * Lists the orders' component needs from their bills (in the product's unit, for the quantity ordered) with what is
+ * available in their warehouse now; as the system (component lines are not edited by hand).
+ */
+async function explode(ids, env) {
+    await env.asSuperuser({ reason: 'production components' }, async (su) => {
+        const orders = await su
+            .model('mrp.production')
+            .browse(ids)
+            .load({ bom: { lines: { product: { uom: true }, uom: true } }, components: true });
+        for (const o of orders) {
+            if (o.components.length > 0)
+                await o.components.unlink();
+            if (o.bom === null)
+                continue;
+            const factor = o.quantity.div(o.bom.quantity);
+            const needs = new Map();
+            for (const l of o.bom.lines) {
+                const inUnit = inProductUnit(l.quantity.times(factor), l.uom ?? null, l.product.uom ?? null);
+                needs.set(l.product.id, (needs.get(l.product.id) ?? zero).plus(inUnit));
+            }
+            const places = await defaultLocations(su, 'internal', o.warehouse?.id ?? null, o.company.id);
+            for (const [product, required] of needs) {
+                let available = zero;
+                if (places.source !== null) {
+                    const quants = await (await su.model('stock.quant').search({
+                        where: {
+                            product: orm.asId(product, 'product.product'),
+                            location: { childOf: places.source },
+                        },
+                    })).load(['quantity', 'reserved']);
+                    available = [...quants].reduce((s, q) => s.plus(q.quantity).minus(q.reserved ?? zero), zero);
+                }
+                await su.model('mrp.production.component').create([
+                    {
+                        production: o.id,
+                        product: orm.asId(product, 'product.product'),
+                        required: required.toDecimalPlaces(4),
+                        available: available.gt(0) ? available : zero,
+                    },
+                ]);
+            }
+        }
+    });
+}
+/** When a work centre's day starts (local time). */
+export const DAY_STARTS_AT = 8;
+/**
+ * Forward schedule of `minutes` of work at a centre working `hoursPerDay` from `DAY_STARTS_AT`, from `from`: what does
+ * not fit in a day continues the next day. Returns the start and the end.
+ */
+export function schedule(from, minutes, hoursPerDay) {
+    const dayStart = (d) => new Date(d.getFullYear(), d.getMonth(), d.getDate(), DAY_STARTS_AT);
+    const dayEnd = (d) => new Date(dayStart(d).getTime() + hoursPerDay * 3_600_000);
+    let at = new Date(Math.max(from.getTime(), dayStart(from).getTime()));
+    if (at >= dayEnd(at))
+        at = dayStart(new Date(at.getTime() + 86_400_000));
+    const start = at;
+    let left = minutes * 60_000;
+    for (;;) {
+        const room = dayEnd(at).getTime() - at.getTime();
+        if (left <= room)
+            return { start, stop: new Date(at.getTime() + left) };
+        left -= room;
+        at = dayStart(new Date(dayStart(at).getTime() + 86_400_000));
+    }
+}
+/**
+ * A step of a production order at a work centre: planned from the bill's operation (its minutes for the quantity
+ * ordered), scheduled after what the centre already has, then started and finished with the minutes it took.
+ */
+export const MrpWorkorder = defineModel('mrp.workorder', {
+    label: 'Work order',
+    tracking: ['state', 'plannedStart', 'workcenter'],
+    recName: 'name',
+    order: ['plannedStart asc', 'id asc'],
+    companyScoped: { required: true },
+    access: {
+        'mrp.user': ['read', 'write'],
+        'mrp.manager': [...ALL, 'export'],
+    },
+    fields: {
+        production: f.many2one('mrp.production', { required: true, ondelete: 'cascade' }),
+        name: f.char({ required: true, label: 'Operation' }),
+        workcenter: f.many2one('mrp.workcenter', { required: true, ondelete: 'restrict' }),
+        plannedMinutes: f.decimal({ scale: 2, required: true, default: '0', label: 'Planned minutes' }),
+        plannedStart: f.datetime({ label: 'Planned start' }),
+        plannedStop: f.datetime({ label: 'Planned end' }),
+        startedAt: f.datetime({ label: 'Started' }),
+        finishedAt: f.datetime({ label: 'Finished' }),
+        /** The minutes it took (from start to finish). */
+        actualMinutes: f.decimal({ scale: 2, label: 'Minutes taken' }),
+        state: f.state({
+            states: { ready: 'Ready', progress: 'In progress', done: 'Done', cancel: 'Cancelled' },
+            initial: 'ready',
+            transitions: {
+                start: {
+                    from: ['ready'],
+                    to: 'progress',
+                    after: records('mrp.workorder', async (orders) => {
+                        await orders.write({ startedAt: new Date() });
+                    }),
+                },
+                finish: {
+                    from: ['progress'],
+                    to: 'done',
+                    after: records('mrp.workorder', async (orders) => {
+                        const now = new Date();
+                        for (const w of await orders.load({})) {
+                            const began = w.startedAt instanceof Date ? w.startedAt : now;
+                            await w.write({
+                                finishedAt: now,
+                                // Whole milliseconds, then minutes (Shutro takes no fractional JS numbers).
+                                actualMinutes: orm
+                                    .toDecimal(now.getTime() - began.getTime())
+                                    .div(60_000)
+                                    .toDecimalPlaces(2),
+                            });
+                        }
+                    }),
+                },
+                /** Done with its order (Produce), however far it got. */
+                close: { from: ['ready', 'progress'], to: 'done' },
+                cancel: { from: ['ready', 'progress'], to: 'cancel' },
+            },
+        }),
+    },
+});
+/**
+ * Makes the orders' work orders from their bills' operations and schedules them forward, step after step, each at
+ * its work centre after what the centre already has planned (from the order's date).
+ */
+async function planWork(ids, env) {
+    await env.asSuperuser({ reason: 'production schedule' }, async (su) => {
+        const orders = await su
+            .model('mrp.production')
+            .browse(ids)
+            .load({ bom: { operations: { workcenter: true } } });
+        for (const o of orders) {
+            if (o.bom === null)
+                continue;
+            const factor = o.quantity.div(o.bom.quantity);
+            // The order's day, local (a date is read as text or as a local midnight).
+            const day = new Date(`${iso(o.date)}T00:00:00`);
+            let after = new Date(day.getFullYear(), day.getMonth(), day.getDate(), DAY_STARTS_AT);
+            for (const op of o.bom.operations) {
+                const minutes = op.minutes.times(factor).toDecimalPlaces(2);
+                // The centre is free after the last step it has that is not done or cancelled.
+                const busy = await (await su.model('mrp.workorder').search({
+                    where: { workcenter: op.workcenter.id, state: { in: ['ready', 'progress'] } },
+                    order: ['plannedStop desc'],
+                    limit: 1,
+                })).load(['plannedStop']);
+                const free = [...busy][0]?.plannedStop;
+                const from = free instanceof Date && free > after ? free : after;
+                const { start, stop } = schedule(from, Number(minutes), Number(op.workcenter.hoursPerDay));
+                await su.model('mrp.workorder').create([
+                    {
+                        production: o.id,
+                        company: o.company.id,
+                        name: op.name,
+                        workcenter: op.workcenter.id,
+                        plannedMinutes: minutes,
+                        plannedStart: start,
+                        plannedStop: stop,
+                    },
+                ]);
+                after = stop;
+            }
+        }
+    });
+}
+/** The places of an order: its warehouse's stock, and the Production location. */
+async function placesOf(env, warehouse, company) {
+    const stock = (await defaultLocations(env, 'internal', warehouse, company)).source;
+    const production = (await env.model('stock.location').search({ where: { usage: 'production' }, limit: 1 })).ids[0];
+    if (stock === null || production === undefined)
+        throw new orm.ValidationError('mrp.production', ['warehouse'], 'There is no stock location or Production location to work from.', 'Check the warehouse in Stockroom › Configuration.');
+    return { stock, production };
+}
+export const MrpProduction = defineModel('mrp.production', {
+    label: 'Production order',
+    recName: 'name',
+    order: ['date desc', 'id desc'],
+    companyScoped: { required: true },
+    tracking: ['state', 'quantity', 'bom'],
+    access: {
+        'mrp.user': ['read', 'write', 'create'],
+        'mrp.manager': [...ALL, 'export', 'import'],
+    },
+    fields: {
+        name: f.char({
+            required: true,
+            readonly: true,
+            sequence: { code: 'mrp.production', dateField: 'date' },
+            label: 'Reference',
+        }),
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        quantity: f.decimal({ scale: 4, required: true, default: '1' }),
+        bom: f.many2one('mrp.bom', { ondelete: 'restrict', label: 'Bill of materials' }),
+        date: f.date({ required: true, default: (env) => env.today(), label: 'Planned for' }),
+        warehouse: f.many2one('stock.warehouse', { ondelete: 'restrict' }),
+        components: f.one2many('mrp.production.component', 'production'),
+        /** Scrap recorded on the order, with its reasons (Stockroom's scrap). */
+        scraps: f.one2many('stock.scrap', 'production'),
+        workorders: f.one2many('mrp.workorder', 'production', { label: 'Work orders' }),
+        consumption: f.many2one('stock.picking', {
+            ondelete: 'set null',
+            label: 'Components transfer',
+        }),
+        output: f.many2one('stock.picking', { ondelete: 'set null', label: 'Output transfer' }),
+        /** The components at their cost. */
+        materialCost: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Materials',
+            ...compute('mrp.production', 'materialCost', ['components.cost'], (orders) => {
+                for (const o of orders)
+                    o.materialCost = [...o.components].reduce((s, c) => s.plus(c.cost ?? zero), zero);
+            }),
+        }),
+        /** The operations at their work centres' cost per hour. */
+        operationCost: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Operations',
+            ...compute('mrp.production', 'operationCost', [
+                'quantity',
+                'bom.quantity',
+                'bom.operations.minutes',
+                'bom.operations.workcenter.costPerHour',
+            ], (orders) => {
+                for (const o of orders) {
+                    if (o.bom === null) {
+                        o.operationCost = zero;
+                        continue;
+                    }
+                    const factor = o.quantity.div(o.bom.quantity);
+                    o.operationCost = money([...o.bom.operations].reduce((s, op) => s.plus(op.minutes.times(factor).div(60).times(op.workcenter.costPerHour)), zero));
+                }
+            }),
+        }),
+        totalCost: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Total cost',
+            ...compute('mrp.production', 'totalCost', ['materialCost', 'operationCost'], (orders) => {
+                for (const o of orders)
+                    o.totalCost = (o.materialCost ?? zero).plus(o.operationCost ?? zero);
+            }),
+        }),
+        unitCost: f.decimal({
+            scale: 4,
+            store: true,
+            label: 'Unit cost',
+            ...compute('mrp.production', 'unitCost', ['totalCost', 'quantity'], (orders) => {
+                for (const o of orders)
+                    o.unitCost = o.quantity.gt(0)
+                        ? (o.totalCost ?? zero).div(o.quantity).toDecimalPlaces(4)
+                        : zero;
+            }),
+        }),
+        /** The one chip: Draft, Waiting (components short), Ready, Done, Cancelled. */
+        status: f.selection({ draft: 'Draft', waiting: 'Waiting', ready: 'Ready', done: 'Done', cancelled: 'Cancelled' }, {
+            store: true,
+            label: 'Status',
+            ...compute('mrp.production', 'status', ['state', 'consumption.availability'], (orders) => {
+                for (const o of orders)
+                    o.status =
+                        o.state === 'confirmed'
+                            ? o.consumption?.availability === 'full'
+                                ? 'ready'
+                                : 'waiting'
+                            : o.state === 'cancel'
+                                ? 'cancelled'
+                                : o.state;
+            }),
+        }),
+        note: f.text(),
+        state: f.state({
+            states: { draft: 'Draft', confirmed: 'Confirmed', done: 'Done', cancel: 'Cancelled' },
+            initial: 'draft',
+            transitions: {
+                /** Lists the components with what is available and short, and the cost, before anything starts. */
+                check: {
+                    from: ['draft', 'confirmed'],
+                    to: 'draft',
+                    guard: records('mrp.production', async (orders) => (await orders.load({})).filter((o) => o.state !== 'draft')),
+                    message: 'A confirmed order is checked with Check availability.',
+                    after: records('mrp.production', async (orders) => {
+                        await explode(orders.ids, orders.env);
+                    }),
+                },
+                confirm: {
+                    from: ['draft'],
+                    to: 'confirmed',
+                    guard: records('mrp.production', async (orders) => (await orders.load({})).filter((o) => o.bom === null)),
+                    message: 'Choose the bill of materials first.',
+                    // The components, their transfer to Production (reserved), and the work orders, scheduled.
+                    after: records('mrp.production', async (orders) => {
+                        await explode(orders.ids, orders.env);
+                        await planWork(orders.ids, orders.env);
+                        const env = orders.env;
+                        for (const o of await env
+                            .model('mrp.production')
+                            .browse(orders.ids)
+                            .load({ components: true })) {
+                            // Nothing to consume (labour only): no components transfer.
+                            if (o.components.length === 0)
+                                continue;
+                            const { stock, production } = await placesOf(env, o.warehouse?.id ?? null, o.company.id);
+                            const made = await env.model('stock.picking').create([
+                                {
+                                    kind: 'production',
+                                    company: o.company.id,
+                                    warehouse: o.warehouse?.id ?? null,
+                                    source: stock,
+                                    destination: production,
+                                    origin: o.name,
+                                    scheduledDate: o.date,
+                                    moves: {
+                                        create: [...o.components].map((c) => ({
+                                            product: c.product.id,
+                                            quantity: c.required,
+                                        })),
+                                    },
+                                },
+                            ]);
+                            await made.confirm();
+                            await env
+                                .model('mrp.production')
+                                .browse([o.id])
+                                .write({ consumption: made.ids[0] ?? null });
+                        }
+                    }),
+                },
+                /** "Check availability": reserve the components that came in since. */
+                reserve: {
+                    from: ['confirmed'],
+                    to: 'confirmed',
+                    after: records('mrp.production', async (orders) => {
+                        const env = orders.env;
+                        for (const o of await env.model('mrp.production').browse(orders.ids).load({}))
+                            if (o.consumption !== null)
+                                await env.model('stock.picking').browse([o.consumption.id]).reserve();
+                    }),
+                },
+                produce: {
+                    from: ['confirmed'],
+                    to: 'done',
+                    guard: records('mrp.production', async (orders) => (await orders.load({ consumption: true })).filter((o) => o.consumption !== null && o.consumption.availability !== 'full')),
+                    message: 'Components are short: check availability, or wait for them to come in.',
+                    before: records('mrp.production', async (orders) => {
+                        const env = orders.env;
+                        // What is left of the work is done with the order.
+                        const open = await env.model('mrp.workorder').search({
+                            where: { production: { in: [...orders.ids] }, state: { in: ['ready', 'progress'] } },
+                        });
+                        if (open.length > 0)
+                            await open.close();
+                        for (const o of await env.model('mrp.production').browse(orders.ids).load({})) {
+                            if (o.consumption !== null)
+                                await env.model('stock.picking').browse([o.consumption.id]).validate();
+                            const { stock, production } = await placesOf(env, o.warehouse?.id ?? null, o.company.id);
+                            const [bill] = o.bom === null
+                                ? []
+                                : await env.model('mrp.bom').browse([o.bom.id]).load({ byproducts: true });
+                            const factor = bill === undefined ? zero : o.quantity.div(bill.quantity);
+                            const made = await env.model('stock.picking').create([
+                                {
+                                    kind: 'production',
+                                    company: o.company.id,
+                                    warehouse: o.warehouse?.id ?? null,
+                                    source: production,
+                                    destination: stock,
+                                    origin: o.name,
+                                    moves: {
+                                        create: [
+                                            { product: o.product.id, quantity: o.quantity },
+                                            ...[...(bill?.byproducts ?? [])].map((b) => ({
+                                                product: b.product.id,
+                                                quantity: b.quantity.times(factor).toDecimalPlaces(4),
+                                                uom: b.uom?.id ?? null,
+                                            })),
+                                        ],
+                                    },
+                                },
+                            ]);
+                            // Linked before it is validated: what values it (mrp_account) finds its order.
+                            await env
+                                .model('mrp.production')
+                                .browse([o.id])
+                                .write({ output: made.ids[0] ?? null });
+                            await made.confirm();
+                            await made.validate();
+                        }
+                    }),
+                },
+                cancel: {
+                    from: ['draft', 'confirmed'],
+                    to: 'cancel',
+                    after: records('mrp.production', async (orders) => {
+                        const env = orders.env;
+                        const open = await env.model('mrp.workorder').search({
+                            where: { production: { in: [...orders.ids] }, state: { in: ['ready', 'progress'] } },
+                        });
+                        for (const w of await open.load({}))
+                            await w.cancel();
+                        for (const o of await env
+                            .model('mrp.production')
+                            .browse(orders.ids)
+                            .load({ consumption: true }))
+                            if (o.consumption !== null &&
+                                o.consumption.state !== 'done' &&
+                                o.consumption.state !== 'cancel')
+                                await env.model('stock.picking').browse([o.consumption.id]).cancel();
+                    }),
+                },
+                redraft: { from: ['cancel'], to: 'draft' },
+            },
+        }),
+    },
+    onchange: {
+        // The bill valid on the order's date, and the company's first warehouse.
+        product: onchange('mrp.production', async (d, env) => {
+            const product = d.get('product');
+            if (product === null || product === undefined)
+                return;
+            d.set('bom', await validBom(env, product, String(d.get('date') ?? env.today())));
+            if ((d.get('warehouse') ?? null) === null)
+                d.set('warehouse', (await defaultLocations(env, 'internal')).warehouse);
+        }),
+        date: onchange('mrp.production', async (d, env) => {
+            const product = d.get('product');
+            if (product === null || product === undefined)
+                return;
+            d.set('bom', await validBom(env, product, String(d.get('date') ?? env.today())));
+        }),
+    },
+    sqlConstraints: {
+        positive: { check: orm.sql `quantity > 0`, message: 'An order makes a positive quantity.' },
+    },
+    constraints: {
+        billOfTheProduct: {
+            ...check('mrp.production', ['bom', 'product'], async (orders) => (await orders.load({ bom: true }))
+                .filter((o) => o.bom !== null && o.bom.product.id !== o.product.id)
+                .map((o) => o.id)),
+            message: 'The bill of materials is for another product.',
+        },
+    },
+});
+/** Scrap recorded on a production order (a broken component, a faulty unit made), with its reason. */
+export const ScrapProduction = extendModel('stock.scrap', {
+    fields: {
+        production: f.many2one('mrp.production', { ondelete: 'set null', label: 'Production order' }),
+    },
+});
+/**
+ * Reorder rules that make (RFC 0024 §2.6): production orders not produced yet are on order; ordering makes one
+ * production order per rule with the bill valid on its date, confirmed (its components reserved, its work planned).
+ */
+export const ReorderMake = extendModel('stock.reorder', {
+    overrides: {
+        pending: async function (next) {
+            const out = await next();
+            const rules = this;
+            const env = rules.env;
+            for (const r of await rules.load({})) {
+                const main = (await defaultLocations(env, 'internal', null, r.company.id))
+                    .warehouse;
+                const orders = await (await env.model('mrp.production').search({
+                    where: {
+                        product: r.product.id,
+                        company: r.company.id,
+                        state: { in: ['draft', 'confirmed'] },
+                    },
+                })).load({});
+                const found = out.get(r.id) ?? [];
+                for (const o of orders)
+                    if ((o.warehouse?.id ?? main) === r.warehouse.id)
+                        found.push({ quantity: o.quantity.toString(), document: o.name });
+                out.set(r.id, found);
+            }
+            return out;
+        },
+        procure: async function (next, quantities) {
+            const out = await next(quantities);
+            const rules = this;
+            const env = rules.env;
+            for (const r of await rules.load({ product: true })) {
+                const qty = quantities.get(r.id);
+                if (r.method !== 'make' || qty === undefined)
+                    continue;
+                const date = new Date(`${env.today()}T00:00:00Z`);
+                date.setUTCDate(date.getUTCDate() + r.leadDays);
+                const when = date.toISOString().slice(0, 10);
+                const bom = await validBom(env, r.product.id, when);
+                if (bom === null)
+                    throw new orm.ValidationError('stock.reorder', ['method'], `${r.product.name} has no bill of materials valid on ${when}.`, 'Add one in Production › Bills of materials, or replenish it another way.');
+                const made = await env.model('mrp.production').create([
+                    {
+                        product: r.product.id,
+                        quantity: qty,
+                        bom,
+                        date: when,
+                        warehouse: r.warehouse.id,
+                        company: r.company.id,
+                        note: 'Replenishment',
+                    },
+                ]);
+                await made.confirm();
+                const [order] = await made.load({});
+                out.set(r.id, order?.name ?? '');
+            }
+            return out;
+        },
+    },
+});
+export const mrpShutro = defineModule({
+    name: 'mrp',
+    version: '0.2.0',
+    depends: [productShutro, stockShutro, contactsShutro, messagingShutro],
+    groups: [
+        orm.defineGroup({ code: 'mrp.user', label: 'Production user', implies: ['stock.user'] }),
+        orm.defineGroup({ code: 'mrp.manager', label: 'Production manager', implies: ['mrp.user'] }),
+    ],
+    sequences: [
+        orm.defineSequence({
+            code: 'mrp.production',
+            prefix: 'MO/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+    ],
+    models: [
+        MrpWorkcenter,
+        MrpBom,
+        MrpBomLine,
+        MrpBomByproduct,
+        MrpBomOperation,
+        MrpProduction,
+        MrpProductionComponent,
+        MrpWorkorder,
+    ],
+    extensions: [ScrapProduction, ReorderMake],
+});