shutro-erp 0.3.5 → 0.3.6

package/dist/purchase_stock/module.js

@@ -2,12 +2,17 @@
  * 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.
+ * confirmed. The order shows its receipts and what is received; each line, its received quantity. An order may name
+ * the warehouse it is delivered to (the main one otherwise). Reorder rules that buy (RFC 0024 §2.6) order on
+ * requests for quotation to their vendor — a draft one from replenishment gets the new lines — and count what is
+ * on requests and orders not received yet as on order. Dropshipped products leave a delivery as it is confirmed:
+ * a dropship transfer from the vendor to the customer, with its request for quotation (no receipt: the vendor
+ * delivers).
  */
 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 { defaultLocations, inProductUnit, 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', {
@@ -15,6 +20,12 @@ export const PickingPurchase = extendModel('stock.picking', {
         purchaseOrder: f.many2one('purchase.order', { ondelete: 'set null', label: 'Purchase order' }),
     },
     overrides: {
+        // Lines of products dropshipped from the warehouse leave the delivery for a dropship and its request.
+        routing: async function (next) {
+            await next();
+            const pickings = this;
+            await dropship(pickings.env, pickings.ids);
+        },
         // A backorder stays with its order.
         backorderValues: async function (next) {
             const out = await next();
@@ -58,6 +69,14 @@ export const LineReceived = extendModel('purchase.order.line', {
 export const OrderReceipts = extendModel('purchase.order', {
     fields: {
         receipts: f.one2many('stock.picking', 'purchaseOrder'),
+        /** The vendor delivers to the customer: the order's transfer is a dropship, never received in stock. */
+        dropship: f.boolean({ default: false, label: 'Dropship' }),
+        /** Where the goods are received (the company's main warehouse when empty). */
+        warehouse: f.many2one('stock.warehouse', {
+            ondelete: 'set null',
+            checkCompany: true,
+            label: 'Deliver to',
+        }),
         receiptState: f.selection({
             nothing: 'Nothing to receive',
             to_receive: 'To receive',
@@ -91,7 +110,13 @@ export async function createReceiptFor(env, orderId) {
         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 });
+            .load({
+            lines: { product: true, uom: true },
+            partner: true,
+            company: true,
+            receipts: true,
+            warehouse: true,
+        });
         if (order === undefined || (order.state !== 'purchase' && order.state !== 'done'))
             return null;
         if ([...order.receipts].some((r) => r.state !== 'cancel'))
@@ -99,7 +124,7 @@ export async function createReceiptFor(env, orderId) {
         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);
+        const places = await defaultLocations(su, 'receipt', order.warehouse?.id ?? 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([
@@ -128,9 +153,220 @@ export async function createReceiptFor(env, orderId) {
         return made.ids[0] ?? null;
     });
 }
+const OPEN_RFQ = ['draft', 'sent', 'to_approve'];
+const isoPlus = (today, days) => {
+    const d = new Date(`${today}T00:00:00Z`);
+    d.setUTCDate(d.getUTCDate() + days);
+    return d.toISOString().slice(0, 10);
+};
+/**
+ * Draft deliveries' lines of products with a dropship rule in the warehouse they leave from go to a dropship
+ * transfer per vendor — vendors to the delivery's customer, with every link of the delivery and its lines (a sales
+ * order's) — and a request for quotation to that vendor, marked as a dropship, linked line by line. A delivery left
+ * with no lines becomes the dropship itself.
+ */
+async function dropship(env, ids) {
+    await env.asSuperuser({ reason: 'dropship' }, async (su) => {
+        const [vendors] = (await su.model('stock.location').search({ where: { usage: 'vendor' }, limit: 1 })).ids;
+        if (vendors === undefined)
+            return;
+        const pickings = await su
+            .model('stock.picking')
+            .browse(ids)
+            .load({
+            source: { warehouse: true },
+            company: true,
+            moves: { product: { purchaseTaxes: true }, uom: true },
+        });
+        for (const p of pickings) {
+            const wh = p.source.warehouse;
+            if (p.kind !== 'delivery' || p.state !== 'draft' || wh === null)
+                continue;
+            const moves = [...p.moves];
+            const byVendor = new Map();
+            for (const m of moves) {
+                const [rule] = await (await su.model('stock.reorder').search({
+                    where: { product: m.product.id, warehouse: wh.id, method: 'dropship' },
+                    limit: 1,
+                })).load({ vendor: true });
+                if (rule?.vendor === null || rule?.vendor === undefined)
+                    continue;
+                const v = byVendor.get(rule.vendor.id) ?? { leadDays: rule.leadDays, moves: [] };
+                v.moves.push(m);
+                byVendor.set(rule.vendor.id, v);
+            }
+            if (byVendor.size === 0)
+                continue;
+            const total = byVendor.size === 1 && [...byVendor.values()][0]?.moves.length === moves.length;
+            const pickingValues = (await su.model('stock.picking').browse([p.id]).backorderValues()).get(p.id);
+            const today = su.today();
+            for (const [vendor, v] of byVendor) {
+                const made = await su.model('purchase.order').create([
+                    {
+                        partner: vendor,
+                        company: p.company.id,
+                        currency: p.company.currency.id,
+                        warehouse: wh.id,
+                        dropship: true,
+                        dateOrder: today,
+                        datePlanned: isoPlus(today, v.leadDays),
+                        origin: p.origin ?? p.name,
+                        lines: {
+                            create: v.moves.map((m) => ({
+                                product: m.product.id,
+                                name: m.name ?? m.product.name,
+                                quantity: m.quantity,
+                                uom: m.uom?.id ?? m.product.uom?.id ?? null,
+                                priceUnit: m.product.standardPrice,
+                                taxes: { set: [...m.product.purchaseTaxes.ids] },
+                            })),
+                        },
+                    },
+                ]);
+                const order = made.ids[0];
+                const orderLines = (await su.model('purchase.order.line').search({
+                    where: { order: order },
+                    order: ['id asc'],
+                })).ids;
+                if (total) {
+                    await su
+                        .model('stock.picking')
+                        .browse([p.id])
+                        .write({ kind: 'dropship', source: vendors, purchaseOrder: order });
+                    for (const [i, m] of v.moves.entries())
+                        await su
+                            .model('stock.move')
+                            .browse([m.id])
+                            .write({ purchaseLine: orderLines[i] ?? null });
+                    continue;
+                }
+                const lineValues = await su
+                    .model('stock.move')
+                    .browse(v.moves.map((m) => m.id))
+                    .backorderValues();
+                const split = await su.model('stock.picking').create([
+                    {
+                        ...pickingValues,
+                        kind: 'dropship',
+                        source: vendors,
+                        next: null,
+                        purchaseOrder: order,
+                        moves: {
+                            create: v.moves.map((m, i) => ({
+                                ...lineValues.get(m.id),
+                                quantity: m.quantity,
+                                purchaseLine: orderLines[i] ?? null,
+                            })),
+                        },
+                    },
+                ]);
+                await su
+                    .model('stock.move')
+                    .browse(v.moves.map((m) => m.id))
+                    .unlink();
+                await su
+                    .model('stock.picking')
+                    .browse(split.ids)
+                    .confirm();
+            }
+        }
+        await su.flush();
+    });
+}
+/** The warehouse an order is received into: its own, else the company's main one. */
+async function receivedInto(env, warehouse, company) {
+    return warehouse ?? (await defaultLocations(env, 'receipt', null, company)).warehouse;
+}
+export const ReorderBuy = extendModel('stock.reorder', {
+    overrides: {
+        // Requests for quotation and orders not received yet (their receipt is still to be made) are on order.
+        pending: async function (next) {
+            const out = await next();
+            const rules = this;
+            const env = rules.env;
+            for (const r of await rules.load({ product: true })) {
+                const lines = await (await env.model('purchase.order.line').search({
+                    where: {
+                        product: r.product.id,
+                        'order.company': r.company.id,
+                        'order.state': { in: [...OPEN_RFQ, 'purchase', 'done'] },
+                    },
+                })).load({ order: { receipts: true }, uom: true, product: { uom: true } });
+                const found = out.get(r.id) ?? [];
+                for (const l of lines) {
+                    if (l.order.dropship)
+                        continue;
+                    if (!OPEN_RFQ.includes(l.order.state) && l.order.receipts.length > 0)
+                        continue;
+                    if ((await receivedInto(env, l.order.warehouse?.id ?? null, r.company.id)) !==
+                        r.warehouse.id)
+                        continue;
+                    const qty = inProductUnit(l.quantity, l.uom, l.product.uom);
+                    found.push({ quantity: qty.toString(), document: l.order.name });
+                }
+                out.set(r.id, found);
+            }
+            return out;
+        },
+        // Buying: one request for quotation per vendor and warehouse — a draft one from replenishment gets the lines.
+        procure: async function (next, quantities) {
+            const out = await next(quantities);
+            const rules = this;
+            const env = rules.env;
+            const today = env.today();
+            for (const r of await rules.load({ product: { purchaseTaxes: true }, company: true })) {
+                const qty = quantities.get(r.id);
+                if (r.method !== 'buy' || r.vendor === null || qty === undefined)
+                    continue;
+                const arrival = new Date(`${today}T00:00:00Z`);
+                arrival.setUTCDate(arrival.getUTCDate() + r.leadDays);
+                const line = {
+                    product: r.product.id,
+                    name: r.product.name,
+                    quantity: qty,
+                    uom: r.product.uom?.id ?? null,
+                    priceUnit: r.product.standardPrice,
+                    taxes: { set: [...r.product.purchaseTaxes.ids] },
+                };
+                const [open] = await (await env.model('purchase.order').search({
+                    where: {
+                        partner: r.vendor.id,
+                        company: r.company.id,
+                        warehouse: r.warehouse.id,
+                        state: 'draft',
+                        origin: 'Replenishment',
+                    },
+                    order: ['id desc'],
+                    limit: 1,
+                })).load({});
+                if (open !== undefined) {
+                    await env.model('purchase.order.line').create([{ ...line, order: open.id }]);
+                    out.set(r.id, open.name);
+                    continue;
+                }
+                const made = await env.model('purchase.order').create([
+                    {
+                        partner: r.vendor.id,
+                        company: r.company.id,
+                        currency: r.company.currency.id,
+                        warehouse: r.warehouse.id,
+                        dateOrder: today,
+                        datePlanned: arrival.toISOString().slice(0, 10),
+                        origin: 'Replenishment',
+                        lines: { create: [line] },
+                    },
+                ]);
+                const [order] = await made.load({});
+                out.set(r.id, order?.name ?? '');
+            }
+            await env.flush();
+            return out;
+        },
+    },
+});
 export const purchaseStockShutro = defineModule({
     name: 'purchase_stock',
-    version: '0.1.0',
+    version: '0.2.0',
     depends: [purchaseShutro, stockShutro, productShutro],
     groups: [
         orm.defineGroup({
@@ -140,5 +376,5 @@ export const purchaseStockShutro = defineModule({
         }),
     ],
     models: [],
-    extensions: [PickingPurchase, MovePurchase, LineReceived, OrderReceipts],
+    extensions: [PickingPurchase, MovePurchase, LineReceived, OrderReceipts, ReorderBuy],
 });

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

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: affe9e70bc2ae97c
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 12ed1cd9243b4281
 // 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';