shutro-erp 0.2.1 → 0.3.1

package/dist/accounting/module.js

@@ -16,10 +16,10 @@
 import { contactsShutro } from '../contacts/index.js';
 import { messagingShutro } from '../messaging/index.js';
 import { approvalGuard, permissionsShutro, requestApprovals } from '../permissions/index.js';
-import { productShutro } from '../product/index.js';
+import { computeTaxes, productShutro, taxRule } from '../product/index.js';
 import { reportingShutro } from '../reporting/index.js';
 import { orm } from '../server/orm.js';
-import { check, compute, defineModel, defineModule, extendModel, f, record, records, ref, } from './.kosh/bindings.js';
+import { check, compute, defineModel, defineModule, extendModel, f, onchange, record, records, ref, } from './.kosh/bindings.js';
 import { postPayments } from './payments.js';
 const READ = ['read'];
 const WRITE = ['read', 'write', 'create'];
@@ -57,7 +57,28 @@ export const MOVE_KINDS = {
     out_refund: 'Customer credit note',
     in_invoice: 'Vendor bill',
     in_refund: 'Vendor credit note',
+    out_debit: 'Customer debit note',
+    in_debit: 'Vendor debit note',
 };
+/** Documents the partner owes the company for: customer invoices and debit notes, vendor credit notes. */
+export function owedToUs(kind) {
+    return kind === 'out_invoice' || kind === 'out_debit' || kind === 'in_refund';
+}
+/** Credit notes (they post the other way round from the invoice they correct). */
+export function isRefund(kind) {
+    return kind === 'out_refund' || kind === 'in_refund';
+}
+/**
+ * The scope of a document: `inter` for a partner in another country, otherwise the place of supply against the
+ * company's state (`intra` when either is unknown: a country without states).
+ */
+export function supplyScope(company, partnerCountry, placeOfSupply) {
+    if (partnerCountry !== null && company.country !== null && partnerCountry !== company.country)
+        return 'inter';
+    if (placeOfSupply === null || company.state === null)
+        return 'intra';
+    return placeOfSupply === company.state ? 'intra' : 'inter';
+}
 /** The kind of the entry that reverses one of each kind. */
 export const REVERSED_KIND = {
     entry: 'entry',
@@ -65,6 +86,8 @@ export const REVERSED_KIND = {
     out_refund: 'out_invoice',
     in_invoice: 'in_refund',
     in_refund: 'in_invoice',
+    out_debit: 'out_refund',
+    in_debit: 'in_refund',
 };
 /**
  * The sequence field numbering each journal type (Shutro numbers one field per sequence code, and a sequence's
@@ -150,6 +173,28 @@ export const AccountJournal = defineModel('account.journal', {
         },
     },
 });
+/** A bank account of the company: shown on its invoices and in the portal, where customers pay (RFC 0016 §5.1). */
+export const ResBankAccount = defineModel('res.bank.account', {
+    label: 'Bank account',
+    order: ['sequence asc', 'id asc'],
+    recName: 'number',
+    archivable: true,
+    companyScoped: { required: true },
+    // The company's payment details are not secret: every user (and the portal, through it) may read them.
+    access: { 'base.user': READ, 'account.manager': ALL },
+    fields: {
+        sequence: f.integer({ required: true, default: 10 }),
+        bank: f.char({ required: true, label: 'Bank' }),
+        branch: f.char(),
+        number: f.char({ required: true, label: 'Account number' }),
+        holder: f.char({ label: 'Account holder' }),
+        /** Routing number (Bangladesh), IFSC (India), sort code… */
+        routing: f.char({ label: 'Routing number' }),
+        swift: f.char({ label: 'SWIFT / BIC' }),
+        /** Shown on invoices in this currency; on every invoice when empty. */
+        currency: f.many2one('res.currency'),
+    },
+});
 export const AccountFiscalYear = defineModel('account.fiscal.year', {
     label: 'Fiscal year',
     order: ['dateFrom desc'],
@@ -166,6 +211,18 @@ export const AccountFiscalYear = defineModel('account.fiscal.year', {
         closingMove: f.many2one('account.move', { label: 'Closing entry' }),
         reopenReason: f.char({ label: 'Reopened because' }),
     },
+    onchange: {
+        // A year that starts on a date ends the day before the same date a year later.
+        dateFrom: onchange('account.fiscal.year', (d) => {
+            const from = d.get('dateFrom');
+            if (typeof from !== 'string')
+                return;
+            const [y, m, day] = from.split('-').map(Number);
+            d.set('dateTo', new Date(Date.UTC(y + 1, m - 1, day - 1)).toISOString().slice(0, 10));
+            if (d.get('name') === null || d.get('name') === '')
+                d.set('name', m === 1 && day === 1 ? String(y) : `${y}–${String(y + 1).slice(2)}`);
+        }),
+    },
     sqlConstraints: {
         datesOrdered: {
             check: orm.sql `date_to > date_from`,
@@ -228,10 +285,29 @@ export const AccountPaymentTermLine = defineModel('account.payment.term.line', {
         daysPositive: { check: orm.sql `days >= 0`, message: 'Days are zero or more.' },
     },
 });
+/** The fiscal year that `date` (ISO) falls in, for years starting in month `start` (1–12): its first and last day. */
+export function fiscalYearOf(date, start) {
+    const [y, m] = date.split('-').map(Number);
+    const year = m >= start ? y : y - 1;
+    const from = new Date(Date.UTC(year, start - 1, 1));
+    const to = new Date(Date.UTC(year + 1, start - 1, 0)); // the day before the next year starts
+    return { dateFrom: from.toISOString().slice(0, 10), dateTo: to.toISOString().slice(0, 10) };
+}
 /** The company's accounting settings: lock dates and the accounts its documents post to. */
 export const CompanyAccounting = extendModel('res.company', {
     fields: {
-        chartTemplate: f.selection({ generic: 'Generic', bd: 'Bangladesh' }, { label: 'Chart of accounts' }),
+        /** The first month of its fiscal years (July in Bangladesh: July–June). */
+        fiscalYearStart: f.integer({
+            required: true,
+            default: 1,
+            label: 'Fiscal year starts in (month, 1–12)',
+        }),
+        /** The installed chart: `generic` or a localization's key (`bd`). */
+        chartTemplate: f.char({ size: 32, label: 'Chart of accounts' }),
+        /** Where the company is registered (ISO 3166): taxes split by place of supply compare against it. */
+        country: f.char({ size: 2, label: 'Country' }),
+        /** Its state or province (ISO 3166-2, `IN-MH`). */
+        state: f.char({ size: 6, label: 'State' }),
         /** Nothing is posted, reversed or reconciled on or before it (everyone). */
         lockDate: f.date({ label: 'Lock date' }),
         /** Tax returns filed up to this date: tax lines cannot change on or before it. */
@@ -242,6 +318,12 @@ export const CompanyAccounting = extendModel('res.company', {
         accountExchangeLoss: f.many2one('account.account', { label: 'Exchange loss account' }),
         accountRetainedEarnings: f.many2one('account.account', { label: 'Retained earnings account' }),
     },
+    sqlConstraints: {
+        fiscalYearMonth: {
+            check: orm.sql `fiscal_year_start BETWEEN 1 AND 12`,
+            message: 'A fiscal year starts in a month from 1 (January) to 12 (December).',
+        },
+    },
 });
 /** The accounts a tax posts to (the tax itself lives in the product module, shared by Sales and Purchase). */
 export const TaxAccounts = extendModel('account.tax', {
@@ -249,8 +331,43 @@ export const TaxAccounts = extendModel('account.tax', {
         account: f.many2one('account.account', { label: 'Tax account' }),
         /** On credit notes, when different from the tax account. */
         refundAccount: f.many2one('account.account', { label: 'Tax account on credit notes' }),
-        /** Taxes included in the unit price (the price is gross). */
-        priceIncluded: f.boolean({ default: false, label: 'Included in price' }),
+        /** Reverse charge: where the tax the company owes the state goes (the tax account takes what it may claim). */
+        reverseChargeAccount: f.many2one('account.account', {
+            label: 'Tax account for reverse charge (payable)',
+        }),
+        /** Its parts (CGST and SGST, or IGST): posted instead of the tax, by the document's scope. */
+        components: f.one2many('account.tax.component', 'tax'),
+    },
+});
+/**
+ * A part of a tax (RFC 0016 step 5): GST 18 % is CGST 9 % and SGST 9 % within a state, IGST 18 % between states.
+ * Lines and totals keep the tax; posting writes a tax line per component of the document's scope, each with its
+ * share of the amount, to its account. The shares of each scope add up to 1.
+ */
+export const AccountTaxComponent = defineModel('account.tax.component', {
+    label: 'Tax component',
+    order: ['sequence asc', 'id asc'],
+    access: { 'account.invoicing': READ, 'account.user': READ, 'account.manager': ALL },
+    fields: {
+        tax: f.many2one('account.tax', { required: true, ondelete: 'cascade' }),
+        sequence: f.integer({ required: true, default: 10 }),
+        name: f.char({ required: true, translate: true }),
+        /** Its part of the tax's amount: 0.5 for half. */
+        share: f.decimal({ scale: 4, required: true, default: '1' }),
+        scope: f.selection({ always: 'Always', intra: 'Within the state', inter: 'Between states or abroad' }, { required: true, default: 'always' }),
+        /** What the returns call it: CGST, SGST, IGST, CESS. */
+        code: f.char({ size: 16 }),
+        account: f.many2one('account.account'),
+        refundAccount: f.many2one('account.account', { label: 'Account on credit notes' }),
+        reverseChargeAccount: f.many2one('account.account', {
+            label: 'Account for reverse charge (payable)',
+        }),
+    },
+    constraints: {
+        shareRange: {
+            ...check('account.tax.component', ['share'], (cs) => cs.filter((c) => c.share.lte(0) || c.share.gt(1))),
+            message: "A component's share is above 0 and at most 1 (0.5 for half).",
+        },
     },
 });
 const moveTotals = compute('account.move', ['amountDebit', 'amountCredit'], ['lines.debit', 'lines.credit', 'lines.companyCurrency'], (moves) => {
@@ -289,7 +406,7 @@ const moveResidual = compute('account.move', ['amountResidual', 'paymentState'],
             continue;
         }
         // The counterpart is a debit on outgoing documents (receivable) and a credit on incoming ones.
-        const sign = m.kind === 'out_invoice' || m.kind === 'in_refund' ? 1 : -1;
+        const sign = owedToUs(m.kind) ? 1 : -1;
         let residual = orm.toDecimal(0);
         for (const l of m.lines)
             if (l.lineKind === 'counterpart')
@@ -398,6 +515,37 @@ export const AccountMove = defineModel('account.move', {
         }),
         // Documents
         dateDue: f.date({ label: 'Due date' }),
+        /** Where to pay a customer invoice: the company's bank accounts in its currency, and the reference to quote. */
+        paymentDetails: f.text({
+            label: 'Payment details',
+            ...compute('account.move', 'paymentDetails', ['kind', 'name', 'currency', 'company'], async (moves) => {
+                for (const m of moves) {
+                    if (m.kind !== 'out_invoice') {
+                        m.paymentDetails = '';
+                        continue;
+                    }
+                    const banks = await moves.env.model('res.bank.account').search({
+                        where: {
+                            company: m.company.id,
+                            or: [{ currency: { isNull: true } }, { currency: m.currency.id }],
+                        },
+                    });
+                    const rows = await banks.load({});
+                    const lines = [...rows].map((b) => [
+                        [b.bank, b.branch].filter((x) => x !== null && x !== '').join(', '),
+                        `A/C ${b.number}${b.holder === null ? '' : ` (${b.holder})`}`,
+                        b.routing === null ? null : `Routing ${b.routing}`,
+                        b.swift === null ? null : `SWIFT ${b.swift}`,
+                    ]
+                        .filter((x) => x !== null && x !== '')
+                        .join(' · '));
+                    m.paymentDetails =
+                        lines.length === 0
+                            ? ''
+                            : [...lines, ...(m.name === '/' ? [] : [`Reference: ${m.name}`])].join('\n');
+                }
+            }),
+        }),
         paymentTerm: f.many2one('account.payment.term', { label: 'Payment terms' }),
         invoiceOrigin: f.char({ label: 'Source document' }),
         amountUntaxed: f.monetary({
@@ -461,6 +609,13 @@ export const AccountMove = defineModel('account.move', {
         /** The database transaction that posted the entry: the immutability checks let that one finish its writes. */
         postedTx: f.char({ size: 32 }),
         reversalOf: f.many2one('account.move', { label: 'Reversal of' }),
+        /** A debit note: the invoice or bill it adds to. */
+        debitOf: f.many2one('account.move', { label: 'Adds to' }),
+        /**
+         * The state where the supply takes place (ISO 3166-2, `IN-KA`): from the partner's state when posted, editable.
+         * Decides whether a tax's within-state or between-states components post.
+         */
+        placeOfSupply: f.char({ size: 6, label: 'Place of supply' }),
         reversedBy: f.many2one('account.move', { label: 'Reversed by' }),
     },
     constraints: {
@@ -613,40 +768,62 @@ export const AccountMoveLine = defineModel('account.move.line', {
         priceUnit: f.decimal({ scale: 2, default: '0', label: 'Unit price' }),
         /** Percent off the unit price (0–100). */
         discount: f.decimal({ scale: 2, default: '0', label: 'Discount %' }),
-        tax: f.many2one('account.tax'),
+        /** A product line's taxes, applied in order (RFC 0016): supplementary duty, then VAT on price + SD. */
+        taxes: f.many2many('account.tax'),
+        /** Before 0.2.0, one tax per line: copied into `taxes` by the migration; dropped later. */
+        tax: f.many2one('account.tax', { label: 'Tax (before 0.2.0)', readonly: true }),
         /** Tax-excluded amount of a product line in the document currency. */
         subtotal: f.monetary({
             currency: 'currency',
             store: true,
             label: 'Subtotal',
-            ...compute('account.move.line', 'subtotal', ['lineKind', 'quantity', 'priceUnit', 'discount', 'tax.rate', 'tax.priceIncluded'], (lines) => {
-                for (const l of lines) {
-                    if (l.lineKind !== 'product') {
-                        l.subtotal = null;
-                        continue;
-                    }
-                    const gross = (l.quantity ?? orm.toDecimal(1))
-                        .times(l.priceUnit ?? 0)
-                        .times(orm.toDecimal(100).minus(l.discount ?? 0))
-                        .div(100);
-                    const rate = l.tax?.rate ?? orm.toDecimal(0);
-                    l.subtotal = l.tax?.priceIncluded === true ? gross.div(rate.plus(1)) : gross;
-                }
+            ...compute('account.move.line', 'subtotal', [
+                'lineKind',
+                'quantity',
+                'priceUnit',
+                'discount',
+                'taxes.rate',
+                'taxes.sequence',
+                'taxes.amountType',
+                'taxes.fixedAmount',
+                'taxes.affectsBase',
+                'taxes.priceIncluded',
+                'taxes.reverseCharge',
+            ], (lines) => {
+                for (const l of lines)
+                    l.subtotal = l.lineKind === 'product' ? taxesOfLine(l).untaxed : null;
             }),
         }),
-        /** The tax of a product line in the document currency (summed and rounded per tax at posting). */
+        /** The taxes of a product line in the document currency (summed and rounded per tax at posting). */
         taxAmount: f.monetary({
             currency: 'currency',
             store: true,
             label: 'Tax',
-            ...compute('account.move.line', 'taxAmount', ['subtotal', 'tax.rate'], (lines) => {
+            ...compute('account.move.line', 'taxAmount', [
+                'lineKind',
+                'quantity',
+                'priceUnit',
+                'discount',
+                'taxes.rate',
+                'taxes.sequence',
+                'taxes.amountType',
+                'taxes.fixedAmount',
+                'taxes.affectsBase',
+                'taxes.priceIncluded',
+                'taxes.reverseCharge',
+            ], (lines) => {
                 for (const l of lines)
-                    l.taxAmount =
-                        l.subtotal === null ? null : l.subtotal.amount.times(l.tax?.rate ?? orm.toDecimal(0));
+                    l.taxAmount = l.lineKind === 'product' ? taxesOfLine(l).taxTotal : null;
             }),
         }),
         /** Set on the generated tax lines: the tax this line is the amount of. */
         taxLineOf: f.many2one('account.tax', { label: 'Tax line for' }),
+        /** On the generated tax lines of a tax with components: which one (CGST, SGST, IGST). */
+        taxComponent: f.many2one('account.tax.component', { label: 'Tax component' }),
+        /** On the generated lines of a reverse-charge tax: claimable and payable, net zero. */
+        taxReverseCharge: f.boolean({ required: true, default: false, label: 'Reverse charge' }),
+        /** On the generated tax lines: what the tax was computed on, in the document currency (the tax reports). */
+        taxBase: f.monetary({ currency: 'currency', label: 'Tax base' }),
         /** Debit minus credit, for the reports (trial balance, ledgers, P&L, balance sheet). */
         balance: f.monetary({
             currency: 'companyCurrency',
@@ -675,18 +852,13 @@ export const AccountMoveLine = defineModel('account.move.line', {
                     l.accountType = l.account?.type ?? null;
             }),
         }),
-        /** The tax a line reports under: a product line's tax (its base), a tax line's tax (its amount). */
+        /** The tax a generated tax line reports under (its amount, with its base in `taxBase`). */
         taxReport: f.many2one('account.tax', {
             store: true,
             label: 'Tax (report)',
-            ...compute('account.move.line', 'taxReport', ['tax', 'taxLineOf', 'lineKind'], (lines) => {
+            ...compute('account.move.line', 'taxReport', ['taxLineOf', 'lineKind'], (lines) => {
                 for (const l of lines)
-                    l.taxReport =
-                        l.lineKind === 'tax'
-                            ? (l.taxLineOf?.id ?? null)
-                            : l.lineKind === 'product'
-                                ? (l.tax?.id ?? null)
-                                : null;
+                    l.taxReport = l.lineKind === 'tax' ? (l.taxLineOf?.id ?? null) : null;
             }),
         }),
         /** Partial matches this line takes part in, on its debit or its credit side (`payments.ts`). */
@@ -730,7 +902,7 @@ export const AccountMoveLine = defineModel('account.move.line', {
                 'quantity',
                 'priceUnit',
                 'discount',
-                'tax',
+                'taxes',
             ], async (lines) => {
                 const loaded = await lines.load({ move: true });
                 const tx = await currentTx(lines.env);
@@ -740,6 +912,15 @@ export const AccountMoveLine = defineModel('account.move.line', {
         },
     },
 });
+/** A product line's taxes (RFC 0016): its amount after discount through the engine. */
+function taxesOfLine(l) {
+    const quantity = l.quantity ?? orm.toDecimal(1);
+    const amount = quantity
+        .times(l.priceUnit ?? 0)
+        .times(orm.toDecimal(100).minus(l.discount ?? 0))
+        .div(100);
+    return computeTaxes(amount, quantity, [...l.taxes].map(taxRule));
+}
 /** The current database transaction's id (assigned on first use; posting writes anyway). */
 async function currentTx(env) {
     const [row] = await env.sql `SELECT pg_current_xact_id()::text AS tx`;
@@ -752,7 +933,8 @@ async function currentTx(env) {
 async function postMoves(moves) {
     const env = moves.env;
     const loaded = await moves.load({
-        lines: { tax: true },
+        lines: { taxes: { components: true } },
+        partner: true,
         journal: true,
         company: { currency: true },
         currency: true,
@@ -788,12 +970,24 @@ async function postMoves(moves) {
                 throw fail(['lines'], 'The document has no product lines.', 'Add at least one line.');
             if (m.partner === null)
                 throw fail(['partner'], 'The document has no partner.', 'Choose the customer or the vendor.');
-            const outgoing = m.kind === 'out_invoice' || m.kind === 'in_refund';
+            const outgoing = owedToUs(m.kind);
             // Product and tax lines of an outgoing document are credits (income), the counterpart a debit.
             const sign = outgoing ? -1 : 1;
-            const refund = m.kind === 'out_refund' || m.kind === 'in_refund';
+            const refund = isRefund(m.kind);
+            const customer = m.kind.startsWith('out_');
             const unit = m.currency.rounding;
             const round = (d) => d.div(unit).toDecimalPlaces(0, orm.Decimal.ROUND_HALF_UP).times(unit);
+            const currency = orm.defineCurrency({
+                code: m.currency.name,
+                rounding: m.currency.rounding,
+                decimalPlaces: m.currency.decimalPlaces ?? 2,
+                id: m.currency.id,
+            });
+            // The place of supply: the partner's state unless set; it decides which components of a tax post.
+            const placeOfSupply = m.placeOfSupply ?? m.partner.state ?? null;
+            if (placeOfSupply !== m.placeOfSupply)
+                await one.write({ placeOfSupply });
+            const scope = supplyScope(m.company, m.partner.country ?? null, placeOfSupply);
             let total = orm.toDecimal(0);
             const byTax = new Map();
             for (const l of products) {
@@ -809,42 +1003,106 @@ async function postMoves(moves) {
                     debit: '0',
                     credit: '0',
                 });
-                if (l.tax !== null) {
-                    const entry = byTax.get(l.tax.id) ?? {
+                // Each tax of the line, in order, with its own base (SD in the VAT's base).
+                for (const t of taxesOfLine(l).taxes) {
+                    const tax = [...l.taxes].find((x) => x.id === t.tax);
+                    if (tax === undefined)
+                        continue;
+                    const entry = byTax.get(t.tax) ?? {
                         amount: orm.toDecimal(0),
-                        account: (refund ? (l.tax.refundAccount?.id ?? l.tax.account?.id) : l.tax.account?.id) ?? null,
-                        name: l.tax.name,
+                        base: orm.toDecimal(0),
+                        tax,
                     };
-                    entry.amount = entry.amount.plus(l.taxAmount?.amount ?? 0);
-                    byTax.set(l.tax.id, entry);
+                    entry.amount = entry.amount.plus(t.amount);
+                    entry.base = entry.base.plus(t.base);
+                    byTax.set(t.tax, entry);
                 }
             }
-            for (const [taxId, t] of byTax) {
-                if (t.account === null)
-                    throw fail(['lines'], `Tax ${t.name} has no account.`, 'Set the tax account on the tax (Accounting › Configuration › Taxes).');
-                const amount = round(t.amount);
+            for (const [taxId, { amount: exact, base, tax }] of byTax) {
+                // A reverse-charge tax is the buyer's to pay to the state: the seller posts nothing.
+                if (tax.reverseCharge && customer)
+                    continue;
+                const amount = round(exact);
                 if (amount.isZero())
                     continue;
-                total = total.plus(amount);
-                await linesOf.create([
-                    {
+                // The tax itself, or its components of the document's scope, the amount allocated by share.
+                const components = [...tax.components].filter((c) => c.scope === 'always' || c.scope === scope);
+                const parts = components.length === 0
+                    ? [
+                        {
+                            component: null,
+                            name: tax.name,
+                            account: (refund ? (tax.refundAccount?.id ?? tax.account?.id) : tax.account?.id) ?? null,
+                            payable: tax.reverseChargeAccount?.id ?? null,
+                            share: orm.toDecimal(1),
+                        },
+                    ]
+                    : components.map((c) => ({
+                        component: c.id,
+                        name: c.name,
+                        account: (refund ? (c.refundAccount?.id ?? c.account?.id) : c.account?.id) ?? null,
+                        payable: c.reverseChargeAccount?.id ?? null,
+                        share: c.share,
+                    }));
+                const shares = parts.reduce((sum, p) => sum.plus(p.share), orm.toDecimal(0));
+                if (!shares.eq(1))
+                    throw fail(['lines'], `The components of ${tax.name} ${scope === 'intra' ? 'within the state' : 'between states'} add up to ${shares.toString()}, not 1.`, 'Fix their shares (Accounting › Configuration › Taxes).');
+                const amounts = parts.length === 1
+                    ? [amount]
+                    : orm.Money.of(amount, currency)
+                        .allocate(parts.map((p) => p.share))
+                        .map((money) => money.amount);
+                for (const [i, part] of parts.entries()) {
+                    if (part.account === null)
+                        throw fail(['lines'], `Tax ${part.name} has no account.`, 'Set the tax account on the tax (Accounting › Configuration › Taxes).');
+                    const value = amounts[i];
+                    const line = {
                         move: m.id,
                         lineKind: 'tax',
-                        account: orm.asId(t.account, 'account.account'),
                         partner: m.partner.id,
-                        name: t.name,
+                        name: part.name,
                         taxLineOf: orm.asId(taxId, 'account.tax'),
-                        amountCurrency: amount.times(sign),
+                        ...(part.component === null
+                            ? {}
+                            : { taxComponent: orm.asId(part.component, 'account.tax.component') }),
+                        taxBase: round(base),
                         debit: '0',
                         credit: '0',
-                    },
-                ]);
+                    };
+                    if (!tax.reverseCharge) {
+                        total = total.plus(value);
+                        await linesOf.create([
+                            {
+                                ...line,
+                                account: orm.asId(part.account, 'account.account'),
+                                amountCurrency: value.times(sign),
+                            },
+                        ]);
+                        continue;
+                    }
+                    // Reverse charge: what the company may claim, and what it owes the state; not in the total.
+                    if (part.payable === null)
+                        throw fail(['lines'], `Tax ${part.name} is a reverse charge without a payable account.`, 'Set its reverse-charge account (Accounting › Configuration › Taxes).');
+                    await linesOf.create([
+                        {
+                            ...line,
+                            taxReverseCharge: true,
+                            account: orm.asId(part.account, 'account.account'),
+                            amountCurrency: value.times(sign),
+                        },
+                        {
+                            ...line,
+                            taxReverseCharge: true,
+                            account: orm.asId(part.payable, 'account.account'),
+                            amountCurrency: value.times(-sign),
+                        },
+                    ]);
+                }
             }
-            const counterpart = outgoing || m.kind === 'out_refund'
-                ? m.company.accountReceivable
-                : m.company.accountPayable;
+            // Customers' documents settle on the receivable account, vendors' on the payable one.
+            const counterpart = customer ? m.company.accountReceivable : m.company.accountPayable;
             if (counterpart === null)
-                throw fail(['partner'], `The company has no ${outgoing || m.kind === 'out_refund' ? 'receivable' : 'payable'} account.`, 'Install a chart of accounts (Accounting › Configuration), or set the account on the company.');
+                throw fail(['partner'], `The company has no ${customer ? 'receivable' : 'payable'} account.`, 'Install a chart of accounts (Accounting › Configuration), or set the account on the company.');
             // One counterpart line per payment term part, the whole rounded total allocated between them.
             // Without payment terms, one part due on the document's due date (or its date).
             const parts = m.paymentTerm === null || m.paymentTerm.lines.length === 0
@@ -855,12 +1113,7 @@ async function postMoves(moves) {
                     },
                 ]
                 : m.paymentTerm.lines.map((pl) => ({ days: pl.days, percent: pl.percent }));
-            const totalMoney = orm.Money.of(total, orm.defineCurrency({
-                code: m.currency.name,
-                rounding: m.currency.rounding,
-                decimalPlaces: m.currency.decimalPlaces ?? 2,
-                id: m.currency.id,
-            }));
+            const totalMoney = orm.Money.of(total, currency);
             const amounts = parts.length === 1 ? [totalMoney] : totalMoney.allocate(parts.map((pt) => pt.percent));
             let latest = m.date;
             for (const [i, part] of parts.entries()) {
@@ -946,6 +1199,8 @@ async function postMoves(moves) {
             throw fail(['lines'], `The entry does not balance: debit ${debit.toFixed(places)} and credit ${credit.toFixed(places)} differ by ${debit.minus(credit).abs().toFixed(places)}.`, 'Make the debits and the credits equal before posting.');
         await one.assignNumber(NUMBER_FIELD[m.journal.type], { date: m.date });
         await one.write({ postedAt: env.now(), postedTx: await currentTx(env) });
+        // For whoever acts on posted documents (e-invoicing, automation), through the outbox: after the commit.
+        await env.emit('account.move.posted', { id: m.id, kind: m.kind });
     }
 }
 /** Whole days from `from` to `to` (YYYY-MM-DD), negative when `to` is earlier. */
@@ -963,6 +1218,68 @@ export function addDays(date, days) {
  * and posts its entry (the journal's account against the receivable / payable) and matches the receivable /
  * payable line with the documents it pays (`payments.ts`).
  */
+/**
+ * A withholding at payment (RFC 0016 §5.1): VAT or income tax that the payer keeps back and pays to the state, such as
+ * Bangladesh's VDS and TDS. `vendor`: we withhold when paying a vendor's bill (the account is a liability to the
+ * state). `customer`: a customer withholds from us when paying our invoice (the account is a receivable from the
+ * state). The base is the documents' untaxed amount, their tax or their total; it applies from a document total.
+ */
+export const AccountWithholding = defineModel('account.withholding', {
+    label: 'Withholding',
+    order: ['sequence asc', 'name asc'],
+    archivable: true,
+    companyScoped: { required: true },
+    access: { 'account.invoicing': READ, 'account.user': READ, 'account.manager': ALL },
+    fields: {
+        name: f.char({ required: true, translate: true }),
+        sequence: f.integer({ required: true, default: 10 }),
+        direction: f.selection({ vendor: 'We withhold when paying vendors', customer: 'Customers withhold from us' }, { required: true, default: 'vendor' }),
+        base: f.selection({ untaxed: 'Untaxed amount', tax: 'Tax amount', total: 'Total' }, { required: true, default: 'untaxed', label: 'Computed on' }),
+        /** 0.05 for 5 %. */
+        rate: f.decimal({ scale: 4, required: true, default: '0' }),
+        /** A document whose total is below it is not withheld from. */
+        threshold: f.decimal({
+            scale: 2,
+            required: true,
+            default: '0',
+            label: 'Applies from (document total)',
+        }),
+        account: f.many2one('account.account', { required: true, checkCompany: true }),
+    },
+    constraints: {
+        rateRange: {
+            ...check('account.withholding', ['rate'], (ws) => ws.filter((w) => w.rate.lte(0) || w.rate.gt(1))),
+            message: 'A withholding rate is above 0 and at most 1 (0.05 for 5 %).',
+        },
+    },
+});
+/** The withholdings that apply to a partner (vendor or customer): what a payment of their documents proposes. */
+export const PartnerWithholdings = extendModel('res.partner', {
+    fields: {
+        withholdings: f.many2many('account.withholding', {
+            relation: 'res_partner_withholding_rel',
+            label: 'Withholdings',
+        }),
+    },
+});
+/** What a payment withheld: the withholding, the base and the amount, in the payment's currency. */
+export const AccountPaymentWithholding = defineModel('account.payment.withholding', {
+    label: 'Payment withholding',
+    access: { 'account.invoicing': WRITE, 'account.user': ALL, 'account.manager': ALL },
+    fields: {
+        payment: f.many2one('account.payment', { required: true, ondelete: 'cascade' }),
+        withholding: f.many2one('account.withholding', { required: true, ondelete: 'restrict' }),
+        currency: f.many2one('res.currency', {
+            store: true,
+            ...compute('account.payment.withholding', 'currency', ['payment.currency'], (lines) => {
+                for (const l of lines)
+                    l.currency = l.payment.currency.id;
+            }),
+        }),
+        base: f.monetary({ currency: 'currency', label: 'Base' }),
+        amount: f.monetary({ currency: 'currency', required: true }),
+    },
+});
 export const AccountPayment = defineModel('account.payment', {
     label: 'Payment',
     order: ['date desc', 'id desc'],
@@ -996,6 +1313,17 @@ export const AccountPayment = defineModel('account.payment', {
         memo: f.char(),
         /** The documents this payment settles (oldest due first); none: an open payment to match later. */
         documents: f.many2many('account.move', { label: 'Pays' }),
+        /** Kept back from the documents (VDS, TDS): the documents are settled by `amount` plus these. */
+        withholdings: f.one2many('account.payment.withholding', 'payment'),
+        amountWithheld: f.monetary({
+            currency: 'currency',
+            store: true,
+            label: 'Withheld',
+            ...compute('account.payment', 'amountWithheld', ['withholdings.amount'], (payments) => {
+                for (const p of payments)
+                    p.amountWithheld = p.withholdings.sum('amount', p.currency);
+            }),
+        }),
         move: f.many2one('account.move', { label: 'Entry' }),
         state: f.state({
             states: { draft: 'Draft', posted: 'Posted', cancel: 'Cancelled' },
@@ -1025,7 +1353,17 @@ const sequence = (type, prefix) => orm.defineSequence({
 });
 export const accountingShutro = defineModule({
     name: 'accounting',
-    version: '0.1.0',
+    version: '0.3.0',
+    migrations: [
+        {
+            version: '0.2.0',
+            description: 'Several taxes per line: the single tax of each line becomes its first',
+            up: async (ctx) => {
+                await ctx.sql `INSERT INTO account_move_line_account_tax_rel (account_move_line_id, account_tax_id)
+          SELECT id, tax_id FROM account_move_line WHERE tax_id IS NOT NULL ON CONFLICT DO NOTHING`;
+            },
+        },
+    ],
     depends: [contactsShutro, productShutro, messagingShutro, permissionsShutro, reportingShutro],
     groups: [
         orm.defineGroup({
@@ -1049,6 +1387,8 @@ export const accountingShutro = defineModule({
     ],
     models: [
         ResCurrencyRate,
+        ResBankAccount,
+        AccountWithholding,
         AccountAccount,
         AccountJournal,
         AccountFiscalYear,
@@ -1059,6 +1399,8 @@ export const accountingShutro = defineModule({
         AccountPartialReconcile,
         AccountFullReconcile,
         AccountPayment,
+        AccountPaymentWithholding,
+        AccountTaxComponent,
     ],
     permissions: [
         orm.definePermission({ code: 'account.post', label: 'Post entries', groups: ['account.user'] }),
@@ -1090,5 +1432,5 @@ export const accountingShutro = defineModule({
         record('account.payment.term.line', 'term_half_now', { term: ref('account.payment.term', 'accounting.term_half'), days: 0, percent: '50' }, { noupdate: true }),
         record('account.payment.term.line', 'term_half_later', { term: ref('account.payment.term', 'accounting.term_half'), days: 30, percent: '50' }, { noupdate: true }),
     ],
-    extensions: [CompanyAccounting, TaxAccounts],
+    extensions: [CompanyAccounting, TaxAccounts, PartnerWithholdings],
 });