shutro-erp 0.3.6 → 0.3.7

package/dist/sale_account/module.js

@@ -3,85 +3,550 @@
  * invoiced with one transition (`invoice`), which creates a draft customer invoice from the order's lines
  * (product, description, quantity, price, discount, taxes) in the company's sales journal; the order shows its
  * invoicing state and its invoices, the invoice its order.
+ *
+ * Credit control (RFC 0028 §3.2): a customer's credit limit (else the company's default) against what they owe —
+ * unpaid posted invoices, confirmed orders not invoiced yet and the order being confirmed —, by the company's mode:
+ * off, warn (shown on the order), block (refused), or approval (the order asks for a credit approval, decided by
+ * Accounting managers through the Approvals engine, and is confirmed when approved). Payment terms on the order (else
+ * the customer's) and its invoice address go to the invoice.
  */
-import { accountingShutro } from '../accounting/index.js';
+import { accountingShutro, salesStopped } from '../accounting/index.js';
+import { approvalGuard, permissionsShutro, requestApprovals } from '../permissions/index.js';
 import { salesShutro } from '../sales/index.js';
 import { orm } from '../server/orm.js';
 import { compute, defineModule, extendModel, f, records } from './.kosh/bindings.js';
+/** The company's credit settings (RFC 0028 §3.2). */
+export const CompanyCredit = extendModel('res.company', {
+    fields: {
+        creditControl: f.selection({
+            off: 'Off',
+            warn: 'Warn on the order',
+            block: 'Refuse the confirmation',
+            approval: 'Ask for an approval',
+        }, {
+            default: 'off',
+            label: 'Credit control',
+            help: 'What happens when confirming an order takes a customer over their credit limit.',
+        }),
+        creditLimitDefault: f.decimal({
+            scale: 2,
+            label: 'Default credit limit',
+            help: 'For customers without a limit of their own; empty: no limit.',
+        }),
+    },
+});
+/** A customer's credit limit and payment terms (RFC 0028 §3.2). */
+export const PartnerCredit = extendModel('res.partner', {
+    fields: {
+        creditLimit: f.decimal({
+            scale: 2,
+            label: 'Credit limit',
+            help: 'What this customer may owe at most (unpaid invoices and orders not invoiced); empty: the company’s default.',
+        }),
+        customerPaymentTerm: f.many2one('account.payment.term', {
+            ondelete: 'set null',
+            label: 'Customer payment terms',
+            help: 'The payment terms of this customer’s orders and invoices, unless an order says otherwise.',
+        }),
+    },
+});
+const zero = orm.toDecimal('0');
+const amountOf = (v) => v === null || v === undefined
+    ? zero
+    : typeof v === 'object' && v !== null && 'amount' in v
+        ? orm.toDecimal(String(v.amount))
+        : orm.toDecimal(String(v));
+/**
+ * What a customer owes in a company — unpaid posted invoices (less credit notes) and confirmed orders not invoiced
+ * yet, `order` left out — and their limit (null: none), read as the system.
+ */
+export async function creditOf(env, partner, company, order) {
+    return env.asSuperuser({ reason: 'credit control' }, async (su) => {
+        let owed = zero;
+        for (const m of await (await su.model('account.move').search({
+            where: {
+                partner: partner,
+                company: company,
+                state: 'posted',
+                kind: { in: ['out_invoice', 'out_debit', 'out_refund'] },
+            },
+        })).load([]))
+            owed =
+                m.kind === 'out_refund'
+                    ? owed.minus(amountOf(m.amountResidual))
+                    : owed.plus(amountOf(m.amountResidual));
+        for (const o of await (await su.model('sale.order').search({
+            where: {
+                partner: partner,
+                company: company,
+                state: { in: ['sale', 'done'] },
+                invoiceState: 'to_invoice',
+                ...(order === null ? {} : { id: { ne: order } }),
+            },
+        })).load([]))
+            owed = owed.plus(amountOf(o.amountTotal));
+        const [p] = await su
+            .model('res.partner')
+            .browse([partner])
+            .load([]);
+        const [c] = await su
+            .model('res.company')
+            .browse([company])
+            .load([]);
+        const limit = p?.creditLimit ??
+            c?.creditLimitDefault ??
+            null;
+        return { owed, limit };
+    });
+}
 export const MoveSaleOrder = extendModel('account.move', {
     fields: {
         saleOrder: f.many2one('sale.order', { label: 'Sales order' }),
     },
 });
+/** An invoice line's order line, and down payments (RFC 0028 §3.3). */
+export const MoveLineSale = extendModel('account.move.line', {
+    fields: {
+        saleLine: f.many2one('sale.order.line', { ondelete: 'set null', label: 'Order line' }),
+        /** A down payment of this order (positive), or its deduction (negative). */
+        downPaymentOf: f.many2one('sale.order', { ondelete: 'set null', label: 'Down payment of' }),
+    },
+});
+/** How much of each order line is invoiced: its invoice lines' quantities (credit notes take back). */
+export const SaleLineInvoicing = extendModel('sale.order.line', {
+    fields: {
+        invoiceLines: f.one2many('account.move.line', 'saleLine'),
+        qtyInvoiced: f.decimal({
+            scale: 3,
+            store: true,
+            label: 'Invoiced',
+            help: 'The quantity on this line’s invoices, less credit notes; cancelled invoices do not count.',
+            ...compute('sale.order.line', 'qtyInvoiced', ['invoiceLines.quantity', 'invoiceLines.move.state', 'invoiceLines.move.kind'], (lines) => {
+                for (const l of lines)
+                    l.qtyInvoiced = [...l.invoiceLines]
+                        .filter((il) => il.move.state !== 'cancel')
+                        .reduce((sum, il) => il.move.kind === 'out_refund'
+                        ? sum.minus(il.quantity ?? zero)
+                        : sum.plus(il.quantity ?? zero), zero);
+            }),
+        }),
+    },
+});
+/** The company's down payment product (made on first use): its income account books down payments. */
+export const CompanyDownPayment = extendModel('res.company', {
+    fields: {
+        downPaymentProduct: f.many2one('product.product', {
+            ondelete: 'restrict',
+            label: 'Down payment product',
+            help: 'The service down payments are invoiced as; made on the first down payment.',
+        }),
+    },
+});
+/**
+ * What each line of `orders` has to invoice now (RFC 0028 §3.3): the ordered quantity, or the delivered one for
+ * products invoiced on delivery (Stockroom's, when installed; services count as delivered), less what is invoiced.
+ */
+export async function toInvoice(env, orderIds) {
+    const out = new Map();
+    const lines = await (await env.model('sale.order.line').search({ where: { order: { in: [...orderIds] } } })).load({ product: true });
+    // Stockroom's delivered quantities, when it is installed.
+    const delivered = new Map();
+    try {
+        const raw = env.model('sale.order.line');
+        const ids = lines.map((l) => l.id);
+        if (ids.length > 0)
+            for (const row of (await raw.browse(ids).load(['qtyDelivered'])).read(['qtyDelivered']))
+                delivered.set(row['id'], orm.toDecimal(String(row['qtyDelivered'] ?? '0')));
+    }
+    catch {
+        // no Stockroom: what was ordered counts as delivered
+    }
+    for (const l of lines) {
+        const byDelivery = l.product?.invoicePolicy === 'delivered' &&
+            l.product?.kind !== 'service' &&
+            delivered.size > 0;
+        const basis = byDelivery ? (delivered.get(l.id) ?? zero) : l.quantity;
+        out.set(l.id, basis.minus(l.qtyInvoiced ?? zero));
+    }
+    return out;
+}
+/**
+ * What each line of `orders` has to credit for what came back (RFC 0030 §3.2): the returned quantity, as far as it is
+ * invoiced beyond what is still delivered — so a return is credited once, whatever the invoicing policy.
+ */
+export async function toCredit(env, orderIds) {
+    const out = new Map();
+    const lines = await (await env.model('sale.order.line').search({ where: { order: { in: [...orderIds] } } })).load({});
+    const ids = lines.map((l) => l.id);
+    const returned = await optionalLineField(env, 'sale.order.line', ids, 'qtyReturned');
+    const delivered = await optionalLineField(env, 'sale.order.line', ids, 'qtyDelivered');
+    if (returned === null || delivered === null)
+        return out; // no Stockroom: nothing comes back
+    for (const l of lines) {
+        const back = returned.get(l.id) ?? zero;
+        if (back.lte(0))
+            continue;
+        const over = (l.qtyInvoiced ?? zero).minus(delivered.get(l.id) ?? zero);
+        const credit = back.lt(over) ? back : over;
+        if (credit.gt(0))
+            out.set(l.id, credit);
+    }
+    return out;
+}
+/** A numeric field of order lines a bridge may add (Stockroom's), by line; null when it is not there. */
+async function optionalLineField(env, model, ids, field) {
+    if (ids.length === 0)
+        return new Map();
+    try {
+        const raw = env.model(model);
+        return new Map((await raw.browse([...ids]).load([field]))
+            .read([field])
+            .map((r) => [r['id'], orm.toDecimal(String(r[field] ?? '0'))]));
+    }
+    catch {
+        return null;
+    }
+}
+/** The down payments of an order not deducted yet (invoiced, less the deductions), as the system. */
+async function downPaymentsLeft(env, order) {
+    return env.asSuperuser({ reason: 'down payments' }, async (su) => {
+        let left = zero;
+        for (const l of await (await su.model('account.move.line').search({ where: { downPaymentOf: order } })).load({ move: true }))
+            if (l.move.state !== 'cancel')
+                left = left.plus((l.priceUnit ?? zero).times(l.quantity ?? zero));
+        return left;
+    });
+}
+/** The company's down payment product, made once. */
+async function downPaymentProduct(env, company) {
+    return env.asSuperuser({ reason: 'down payment product' }, async (su) => {
+        const [c] = await su
+            .model('res.company')
+            .browse([company])
+            .load({ downPaymentProduct: true });
+        const existing = c?.downPaymentProduct?.id;
+        if (existing !== undefined)
+            return existing;
+        const made = await su
+            .model('product.product')
+            .create([
+            { name: 'Down payment', kind: 'service', saleOk: false, purchaseOk: false },
+        ]);
+        const id = made.ids[0];
+        await su
+            .model('res.company')
+            .browse([company])
+            .write({ downPaymentProduct: id });
+        return id;
+    });
+}
+/**
+ * A draft customer invoice for an order (RFC 0028 §3.3): the given lines, to its invoice address with its payment
+ * terms, else the customer's. @throws when the company has no sales journal
+ */
+async function invoiceFor(env, order, lines, kind = 'out_invoice') {
+    const [o] = await env
+        .model('sale.order')
+        .browse([order])
+        .load({
+        partner: true,
+        partnerInvoice: true,
+        paymentTerm: true,
+        currency: true,
+        company: true,
+    });
+    if (o === undefined)
+        throw new orm.ValidationError('sale.order', [], 'No such order.', '');
+    const journal = await env.model('account.journal').search({
+        where: { company: o.company.id, type: 'sale' },
+        limit: 1,
+    });
+    const journalId = journal.ids[0];
+    if (journalId === undefined)
+        throw new orm.ValidationError('sale.order', ['state'], 'The company has no sales journal.', 'Install a chart of accounts (Accounting › Configuration).');
+    const made = await env.model('account.move').create([
+        {
+            kind,
+            journal: journalId,
+            // The invoice address and payment terms of the order, else the customer's (RFC 0028 §3.2).
+            partner: o.partnerInvoice?.id ?? o.partner.id,
+            paymentTerm: o.paymentTerm?.id ?? o.partner.customerPaymentTerm?.id ?? null,
+            currency: o.currency.id,
+            company: o.company.id,
+            date: env.today(),
+            invoiceOrigin: o.name,
+            saleOrder: o.id,
+            lines: { create: lines },
+        },
+    ]);
+    return made.ids[0];
+}
+/**
+ * A down payment on a confirmed order (RFC 0028 §3.3): a percent of its total or an amount, invoiced on the
+ * company's down payment product; the next invoices deduct it. Returns the invoice.
+ */
+export async function downPayment(env, order, input) {
+    const [o] = await env
+        .model('sale.order')
+        .browse([order])
+        .load({ company: true });
+    if (o === undefined)
+        throw new orm.ValidationError('sale.order', [], 'No such order.', '');
+    if (o.state !== 'sale')
+        throw new orm.ValidationError('sale.order', ['state'], 'Down payments are for confirmed orders.', 'Confirm the order first.');
+    const total = amountOf(o.amountTotal);
+    const amount = input.amount ?? (input.percent === undefined ? zero : total.times(input.percent).div(100));
+    const left = await downPaymentsLeft(env, order);
+    if (amount.lte(0) || amount.plus(left).gt(total))
+        throw new orm.ValidationError('sale.order', [], `A down payment is more than nothing and, with those not deducted yet (${left.toFixed(2)}), at most the order’s total (${total.toFixed(2)}).`, 'Give a smaller amount or percent.');
+    const product = await downPaymentProduct(env, o.company.id);
+    return invoiceFor(env, order, [
+        {
+            lineKind: 'product',
+            product,
+            name: `Down payment on ${String(o.name)}`,
+            quantity: '1',
+            priceUnit: amount.toDecimalPlaces(2).toString(),
+            downPaymentOf: order,
+            debit: '0',
+            credit: '0',
+        },
+    ]);
+}
 export const SaleOrderInvoicing = extendModel('sale.order', {
     fields: {
+        /** The order's payment terms (RFC 0028 §3.2); empty: the customer's, on the invoice. */
+        paymentTerm: f.many2one('account.payment.term', {
+            ondelete: 'restrict',
+            label: 'Payment terms',
+            help: 'Passed to the invoice; empty: the customer’s payment terms.',
+        }),
+        /** What the last credit check found (RFC 0028 §3.2), shown on the order. */
+        creditNote: f.char({ label: 'Credit' }),
+        /** The next down payment (RFC 0028 §3.3): a percent of the total or an amount; cleared once invoiced. */
+        downPaymentPercent: f.decimal({
+            scale: 2,
+            label: 'Down payment %',
+            help: 'A percent of the order’s total, invoiced by “Invoice a down payment”.',
+        }),
+        downPaymentAmount: f.decimal({
+            scale: 2,
+            label: 'Down payment amount',
+            help: 'An amount, invoiced by “Invoice a down payment” (used instead of the percent).',
+        }),
+        /** Waiting for a credit approval (the approval policy's condition). */
+        creditHeld: f.boolean({ default: false, label: 'Held for credit' }),
         invoices: f.one2many('account.move', 'saleOrder'),
         invoiceState: f.selection({ no: 'Nothing to invoice', to_invoice: 'To invoice', invoiced: 'Invoiced' }, {
             store: true,
             label: 'Invoicing',
-            ...compute('sale.order', 'invoiceState', ['state', 'invoices.state'], (orders) => {
+            help: 'To invoice while some ordered quantity is not invoiced yet; invoiced when all of it is.',
+            ...compute('sale.order', 'invoiceState', ['state', 'lines.quantity', 'lines.qtyInvoiced'], (orders) => {
                 for (const o of orders)
                     o.invoiceState =
                         o.state === 'sale' || o.state === 'done'
-                            ? o.invoices.filter((i) => i.state !== 'cancel').length > 0
+                            ? o.lines.length > 0 &&
+                                [...o.lines].every((l) => (l.qtyInvoiced ?? zero).gte(l.quantity))
                                 ? 'invoiced'
                                 : 'to_invoice'
                             : 'no';
             }),
         }),
     },
+    overrides: {
+        // The credit check before a confirmation (RFC 0028 §3.2).
+        confirming: async function (next) {
+            await next();
+            const orders = this;
+            const env = orders.env;
+            for (const o of await env
+                .model('sale.order')
+                .browse([...orders.ids])
+                .load({ company: true, partner: true })) {
+                // A customer at a follow-up level that stops sales (RFC 0029 §3.4) is not sold to until they pay.
+                const stopped = await salesStopped(env, o.partner.id);
+                if (stopped !== null)
+                    throw new orm.ValidationError('sale.order', ['state'], `Sales to ${String(o.partner.name)} are on hold: their payment follow-up reached "${stopped.level}".`, 'Collect the overdue invoices first, or pause their follow-up in Accounting › Follow-ups.');
+                const mode = String(o.company.creditControl ?? 'off');
+                if (mode === 'off')
+                    continue;
+                const { owed, limit } = await creditOf(env, o.partner.id, o.company.id, o.id);
+                if (limit === null)
+                    continue;
+                const total = owed.plus(amountOf(o.amountTotal));
+                const note = `Owes ${owed.toFixed(2)}; with this order ${total.toFixed(2)}, limit ${limit.toFixed(2)}.`;
+                if (total.lte(limit)) {
+                    if (o.creditNote !== null)
+                        await env.model('sale.order').browse([o.id]).write({ creditNote: null });
+                    continue;
+                }
+                if (mode === 'warn') {
+                    await env
+                        .model('sale.order')
+                        .browse([o.id])
+                        .write({ creditNote: `Over the credit limit. ${note}` });
+                    continue;
+                }
+                throw new orm.ValidationError('sale.order', ['state'], `${String(o.name)} takes ${String(o.partner.name)} over their credit limit. ${note}`, mode === 'approval'
+                    ? 'Ask for a credit approval instead (Accounting managers decide).'
+                    : 'Collect a payment first, or raise the customer’s limit.');
+            }
+        },
+    },
     fieldOverrides: {
         state: {
+            statesAdd: { credit: 'Credit approval' },
             transitionsAdd: {
+                // Over the limit, in approval mode: the order waits for Accounting managers.
+                askCredit: {
+                    from: ['draft', 'sent'],
+                    to: 'credit',
+                    guard: records('sale.order', async (orders) => {
+                        const loaded = await orders.load({ lines: true, company: true });
+                        return loaded.filter((o) => o.lines.length === 0 || o.company.creditControl !== 'approval');
+                    }),
+                    message: 'Credit approvals are for orders with lines, when the company asks for them.',
+                    after: records('sale.order', async (orders) => {
+                        const env = orders.env;
+                        for (const o of await orders.load({ company: true, partner: true })) {
+                            const { owed, limit } = await creditOf(env, o.partner.id, o.company.id, o.id);
+                            const total = owed.plus(amountOf(o.amountTotal));
+                            await env
+                                .model('sale.order')
+                                .browse([o.id])
+                                .write({
+                                creditHeld: true,
+                                creditNote: `Waiting for a credit approval: with this order ${total.toFixed(2)}, limit ${limit === null ? 'none' : limit.toFixed(2)}.`,
+                            });
+                        }
+                        await requestApprovals(orders);
+                    }),
+                },
+                creditApprove: {
+                    from: ['credit'],
+                    to: 'sale',
+                    guard: records('sale.order', (orders) => approvalGuard(orders)),
+                    message: 'Waiting for the credit approval.',
+                    after: records('sale.order', async (orders) => {
+                        for (const o of await orders.load({})) {
+                            await orders.env.emit('sale.order.confirmed', { id: o.id });
+                            await orders.env
+                                .model('sale.order')
+                                .browse([o.id])
+                                .write({ creditHeld: false, creditNote: null });
+                        }
+                    }),
+                },
+                creditReject: {
+                    from: ['credit'],
+                    to: 'draft',
+                    after: records('sale.order', async (orders) => {
+                        for (const o of await orders.load({}))
+                            await orders.env
+                                .model('sale.order')
+                                .browse([o.id])
+                                .write({ creditHeld: false, creditNote: 'The credit approval was refused.' });
+                    }),
+                },
+                // A down payment: the amount typed in, else the percent; the next invoices deduct it.
+                invoiceDownPayment: {
+                    from: ['sale'],
+                    to: 'sale',
+                    guard: records('sale.order', async (orders) => (await orders.load({})).filter((o) => o.downPaymentAmount === null && o.downPaymentPercent === null)),
+                    message: 'Give a down payment percent or amount first.',
+                    after: records('sale.order', async (orders) => {
+                        const env = orders.env;
+                        for (const o of await orders.load({})) {
+                            await downPayment(env, o.id, {
+                                ...(o.downPaymentAmount !== null
+                                    ? { amount: o.downPaymentAmount }
+                                    : { percent: o.downPaymentPercent ?? zero }),
+                            });
+                            await env
+                                .model('sale.order')
+                                .browse([o.id])
+                                .write({ downPaymentAmount: null, downPaymentPercent: null });
+                        }
+                    }),
+                },
+                // A credit note for what the customer sent back (RFC 0030 §3.2), at the line's price.
+                refund: {
+                    from: ['sale'],
+                    to: 'sale',
+                    guard: records('sale.order', async (orders) => {
+                        const due = await toCredit(orders.env, [...orders.ids]);
+                        const loaded = await orders.load({ lines: true });
+                        return loaded.filter((o) => ![...o.lines].some((l) => due.has(l.id)));
+                    }),
+                    message: 'Nothing to credit: no return of this order is invoiced and not credited yet.',
+                    after: records('sale.order', async (orders) => {
+                        const env = orders.env;
+                        const due = await toCredit(env, [...orders.ids]);
+                        for (const o of await orders.load({ lines: { product: true, taxes: true } })) {
+                            const lines = [...o.lines]
+                                .filter((l) => due.has(l.id))
+                                .map((l) => ({
+                                lineKind: 'product',
+                                product: l.product.id,
+                                name: `${String(l.name)} (returned)`,
+                                quantity: (due.get(l.id) ?? zero).toString(),
+                                priceUnit: l.priceUnit,
+                                discount: l.discount,
+                                taxes: { set: [...l.taxes].map((t) => t.id) },
+                                saleLine: l.id,
+                                debit: '0',
+                                credit: '0',
+                            }));
+                            if (lines.length > 0)
+                                await invoiceFor(env, o.id, lines, 'out_refund');
+                        }
+                    }),
+                },
                 invoice: {
                     from: ['sale'],
                     to: 'sale',
+                    // Something to invoice now: ordered, or delivered for products invoiced on delivery, not invoiced yet.
                     guard: records('sale.order', async (orders) => {
-                        const loaded = await orders.load({ invoices: true });
-                        return loaded.filter((o) => o.invoices.filter((i) => i.state !== 'cancel').length > 0);
+                        const due = await toInvoice(orders.env, [...orders.ids]);
+                        const loaded = await orders.load({ lines: true });
+                        return loaded.filter((o) => ![...o.lines].some((l) => (due.get(l.id) ?? zero).gt(0)));
                     }),
-                    message: 'This order is invoiced already.',
+                    message: 'Nothing to invoice now: this order is invoiced already, as far as it is ordered or delivered.',
                     after: records('sale.order', async (orders) => {
                         const env = orders.env;
-                        const loaded = await orders.load({
+                        const due = await toInvoice(env, [...orders.ids]);
+                        for (const o of await orders.load({
                             lines: { product: true, taxes: true },
-                            partner: true,
-                            currency: true,
                             company: true,
-                        });
-                        for (const o of loaded) {
-                            const journal = await env.model('account.journal').search({
-                                where: { company: o.company.id, type: 'sale' },
-                                limit: 1,
-                            });
-                            const journalId = journal.ids[0];
-                            if (journalId === undefined)
-                                throw new orm.ValidationError('sale.order', ['state'], 'The company has no sales journal.', 'Install a chart of accounts (Accounting › Configuration).');
-                            await env.model('account.move').create([
-                                {
-                                    kind: 'out_invoice',
-                                    journal: journalId,
-                                    partner: o.partner.id,
-                                    currency: o.currency.id,
-                                    company: o.company.id,
-                                    date: env.today(),
-                                    invoiceOrigin: o.name,
-                                    saleOrder: o.id,
-                                    lines: {
-                                        create: o.lines.map((l) => ({
-                                            lineKind: 'product',
-                                            product: l.product.id,
-                                            name: l.name,
-                                            quantity: l.quantity,
-                                            priceUnit: l.priceUnit,
-                                            discount: l.discount,
-                                            taxes: { set: [...l.taxes].map((t) => t.id) },
-                                            debit: '0',
-                                            credit: '0',
-                                        })),
-                                    },
-                                },
-                            ]);
+                        })) {
+                            const lines = [...o.lines]
+                                .filter((l) => (due.get(l.id) ?? zero).gt(0))
+                                .map((l) => ({
+                                lineKind: 'product',
+                                product: l.product.id,
+                                name: l.name,
+                                quantity: (due.get(l.id) ?? zero).toString(),
+                                priceUnit: l.priceUnit,
+                                discount: l.discount,
+                                taxes: { set: [...l.taxes].map((t) => t.id) },
+                                saleLine: l.id,
+                                debit: '0',
+                                credit: '0',
+                            }));
+                            // Down payments not deducted yet come off this invoice.
+                            const left = await downPaymentsLeft(env, o.id);
+                            if (left.gt(0))
+                                lines.push({
+                                    lineKind: 'product',
+                                    product: await downPaymentProduct(env, o.company.id),
+                                    name: `Down payment deducted (${String(o.name)})`,
+                                    quantity: '1',
+                                    priceUnit: left.negated().toString(),
+                                    downPaymentOf: o.id,
+                                    debit: '0',
+                                    credit: '0',
+                                });
+                            await invoiceFor(env, o.id, lines);
                         }
                     }),
                 },
@@ -91,8 +556,24 @@ export const SaleOrderInvoicing = extendModel('sale.order', {
 });
 export const saleAccountShutro = defineModule({
     name: 'sale_account',
-    version: '0.1.0',
-    depends: [salesShutro, accountingShutro],
+    version: '0.3.0',
+    migrations: [
+        {
+            version: '0.3.0',
+            description: 'Invoicing by line: existing invoice lines linked to their order lines (same order, product and description), so invoiced orders are not invoiced again',
+            up: async (ctx) => {
+                await ctx.sql `UPDATE account_move_line ml SET sale_line_id = sol.id
+          FROM account_move m, sale_order_line sol
+          WHERE ml.move_id = m.id AND m.sale_order_id = sol.order_id AND ml.product_id = sol.product_id
+            AND ml.name = sol.name AND ml.line_kind = 'product' AND ml.sale_line_id IS NULL`;
+                await ctx.sql `UPDATE sale_order_line sol SET qty_invoiced = coalesce((
+          SELECT sum(CASE WHEN m.kind = 'out_refund' THEN -ml.quantity ELSE ml.quantity END)
+          FROM account_move_line ml JOIN account_move m ON m.id = ml.move_id
+          WHERE ml.sale_line_id = sol.id AND m.state <> 'cancel'), 0)`;
+            },
+        },
+    ],
+    depends: [salesShutro, accountingShutro, permissionsShutro],
     groups: [
         orm.defineGroup({
             code: 'sale_account.user',
@@ -101,5 +582,13 @@ export const saleAccountShutro = defineModule({
         }),
     ],
     models: [],
-    extensions: [MoveSaleOrder, SaleOrderInvoicing],
+    extensions: [
+        MoveSaleOrder,
+        MoveLineSale,
+        SaleLineInvoicing,
+        SaleOrderInvoicing,
+        CompanyCredit,
+        PartnerCredit,
+        CompanyDownPayment,
+    ],
 });

package/dist/sale_crm/.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'];