shutro-erp 0.3.6 → 0.3.7

package/dist/purchase/module.js

@@ -10,9 +10,14 @@ import { approvalGuard, permissionsShutro, requestApprovals } from '../permissio
 import { computeTaxes, productShutro, taxRule } from '../product/index.js';
 import { orm } from '../server/orm.js';
 import { check, compute, defineModel, defineModule, extendModel, f, method, onchange, records, } from './.kosh/bindings.js';
+import { PurchaseComparison, PurchaseComparisonLine, PurchaseTechnicalComparison, PurchaseTechnicalComparisonLine, } from './comparison.js';
+import { agreementPriceFor, checkAgreement, PurchaseAgreement, PurchaseAgreementLine, PurchaseVendorRequest, PurchaseWorkAcceptance, PurchaseWorkAcceptanceLine, } from './extras.js';
+import { PurchaseRequest, PurchaseRequestLine } from './request.js';
+import { PurchaseTender, PurchaseTenderLine, PurchaseTenderResponse, PurchaseTenderResponseLine, } from './tender.js';
+import { ProductVendorPrice, vendorPriceFor } from './vendorprice.js';
 /** A line's taxes through the engine (RFC 0016): its amount, its taxes in order. */
 function taxesOf(l) {
-    return computeTaxes(l.quantity.times(l.priceUnit), l.quantity, [...l.taxes].map(taxRule));
+    return computeTaxes(l.quantity.times(l.priceUnit ?? orm.toDecimal('0')), l.quantity, [...l.taxes].map(taxRule));
 }
 const amounts = compute('purchase.order', ['amountUntaxed', 'amountTax', 'amountTotal'], ['lines.subtotal', 'lines.taxAmount'], (orders) => {
     for (const o of orders) {
@@ -62,11 +67,62 @@ export const PurchaseOrder = defineModel('purchase.order', {
         datePlanned: f.date({ label: 'Expected arrival' }),
         origin: f.char({ label: 'Source document' }),
         note: f.text({ label: 'Terms and conditions' }),
+        // The group's order header (RFC 0032 §3.4).
+        poType: f.selection({ general: 'General', service: 'Service', capital: 'Capital (asset)' }, {
+            required: true,
+            default: 'general',
+            label: 'PO type',
+            help: 'Goods in general, a service (accepted by work acceptance), or a capital purchase (an asset).',
+        }),
+        sourcing: f.selection({ local: 'Local', import: 'Import' }, {
+            required: true,
+            default: 'local',
+            help: 'Bought in the country, or imported (a letter of credit may follow with Trade Finance).',
+        }),
+        advancePercent: f.decimal({
+            scale: 2,
+            default: '0',
+            label: 'Advance (%)',
+            help: 'The share of the order paid before delivery, as agreed with the vendor.',
+        }),
+        agreement: f.many2one('purchase.agreement', {
+            ondelete: 'restrict',
+            help: 'The blanket order or contract this order draws on: its prices, within its quantities and dates.',
+        }),
+        acceptances: f.one2many('purchase.work.acceptance', 'order', { label: 'Work acceptances' }),
+        acceptanceCount: f.integer({
+            store: true,
+            label: 'Work acceptances',
+            help: 'Once an order has one, its service lines are billed up to what was accepted.',
+            ...compute('purchase.order', 'acceptanceCount', ['acceptances.state'], (orders) => {
+                for (const o of orders)
+                    o.acceptanceCount = [...o.acceptances].filter((a) => a.state === 'accepted').length;
+            }),
+        }),
         lines: f.one2many('purchase.order.line', 'order'),
-        amountUntaxed: f.monetary({ currency: 'currency', store: true, label: 'Untaxed', ...amounts }),
-        amountTax: f.monetary({ currency: 'currency', store: true, label: 'Taxes', ...amounts }),
-        amountTotal: f.monetary({ currency: 'currency', store: true, label: 'Total', ...amounts }),
+        amountUntaxed: f.monetary({
+            currency: 'currency',
+            store: true,
+            label: 'Untaxed',
+            help: 'The sum of the lines’ amounts before taxes.',
+            ...amounts,
+        }),
+        amountTax: f.monetary({
+            currency: 'currency',
+            store: true,
+            label: 'Taxes',
+            help: 'The sum of the taxes on the lines.',
+            ...amounts,
+        }),
+        amountTotal: f.monetary({
+            currency: 'currency',
+            store: true,
+            label: 'Total',
+            help: 'What the order costs with its taxes: the untaxed amount plus the taxes.',
+            ...amounts,
+        }),
         state: f.state({
+            help: 'A request for quotation until it is submitted; once approved it becomes a purchase order, which can then be locked or cancelled.',
             states: {
                 draft: 'RFQ',
                 sent: 'RFQ sent',
@@ -114,8 +170,43 @@ export const PurchaseOrder = defineModel('purchase.order', {
         }),
     },
     methods: {
-        /** Before the approvals of a submission: nothing here; account_budget checks the budgets. */
-        submitting: method('purchase.order', async () => undefined),
+        /** Before the approvals of a submission: the agreement's limits (RFC 0032 §3.4); account_budget adds its budgets. */
+        submitting: method('purchase.order', async function () {
+            const orders = this;
+            await checkAgreement(orders.env, orders.ids);
+        }),
+        /**
+         * The approvers each order names for an approval level where "the record decides" (RFC 0027 §2.1): the approvers
+         * of its lines' product categories (the nearest category up the tree that names some).
+         */
+        approvalUsers: method('purchase.order', async function (_key) {
+            const orders = this;
+            const out = new Map();
+            for (const order of await orders.env
+                .model('purchase.order')
+                .browse([...orders.ids])
+                .load({ lines: { product: { category: true } } })) {
+                const people = new Set();
+                for (const line of order.lines) {
+                    let category = line.product?.category?.id;
+                    for (let depth = 0; category !== undefined && depth < 10; depth += 1) {
+                        const [c] = await orders.env
+                            .model('product.category')
+                            .browse([category])
+                            .load({ approvalUsers: true, parent: true });
+                        const users = (c?.approvalUsers ?? []);
+                        if (users.length > 0) {
+                            for (const u of users)
+                                people.add(u.id);
+                            break;
+                        }
+                        category = c?.parent?.id;
+                    }
+                }
+                out.set(order.id, [...people]);
+            }
+            return out;
+        }),
     },
     onchange: {
         // The vendor's currency, else the company's; empty terms from the company's settings.
@@ -146,6 +237,52 @@ export const CompanyPurchase = extendModel('res.company', {
         purchaseTerms: f.text({ label: 'Default terms and conditions' }),
     },
 });
+/** A purchase line's price and why (RFC 0030 §3.1): typed in, else the vendor's price, else the product's cost. */
+async function purchaseLinePrice(l) {
+    if (l.manualPrice !== null)
+        return { price: l.manualPrice, reason: 'Typed in.', code: null };
+    if (l.product === null)
+        return { price: orm.toDecimal('0'), reason: null, code: null };
+    const env = l.env;
+    const date = String(l.order?.dateOrder ?? env.today()).slice(0, 10);
+    // An agreement the order draws on fixes the price (RFC 0032 §3.4).
+    const agreement = l.order?.agreement?.id ?? null;
+    if (agreement !== null) {
+        const fixed = await agreementPriceFor(env, agreement, l.product.id, date);
+        if (fixed !== null)
+            return { price: fixed.price, reason: `Agreement ${fixed.name}.`, code: null };
+    }
+    const vendor = l.order?.partner?.id ?? null;
+    const choice = vendor === null
+        ? null
+        : await vendorPriceFor(env, {
+            product: l.product.id,
+            quantity: l.quantity,
+            date,
+            vendor,
+            currency: l.order?.currency?.id ?? null,
+        });
+    if (choice !== null)
+        return { price: choice.price, reason: choice.explanation, code: choice.vendorCode };
+    const [product] = await env
+        .model('product.product')
+        .browse([l.product.id])
+        .load(['standardPrice']);
+    return {
+        price: product?.standardPrice ?? orm.toDecimal('0'),
+        reason: 'The product’s cost: this vendor has no price for it.',
+        code: null,
+    };
+}
+const PRICE_DEPENDS = [
+    'product',
+    'quantity',
+    'manualPrice',
+    'order.partner',
+    'order.dateOrder',
+    'order.currency',
+    'order.agreement',
+];
 export const PurchaseOrderLine = defineModel('purchase.order.line', {
     label: 'Purchase line',
     access: {
@@ -158,12 +295,72 @@ export const PurchaseOrderLine = defineModel('purchase.order.line', {
         name: f.char({ required: true, label: 'Description' }),
         quantity: f.decimal({ scale: 3, required: true, default: '1' }),
         uom: f.many2one('uom.uom', { label: 'Unit' }),
-        priceUnit: f.decimal({ scale: 2, required: true, default: '0', label: 'Unit price' }),
+        /**
+         * The unit price: the one typed in, else the vendor's price for the quantity and date (RFC 0030 §3.1), else the
+         * product's cost. Typing a price keeps it (`manualPrice`).
+         */
+        priceUnit: f.decimal({
+            scale: 2,
+            store: true,
+            label: 'Unit price',
+            help: 'The price typed in, else the vendor’s price for this quantity and date (see why on the line), else the product’s cost.',
+            ...compute('purchase.order.line', 'priceUnit', [...PRICE_DEPENDS], async (lines) => {
+                for (const l of lines)
+                    l.priceUnit = (await purchaseLinePrice(l)).price;
+            }),
+            inverse: async (records) => {
+                const lines = records;
+                const env = records.env;
+                for (const l of lines)
+                    await env
+                        .model('purchase.order.line')
+                        .browse([l.id])
+                        .write({ manualPrice: l.priceUnit });
+            },
+        }),
+        /** The price typed in, kept when the product, the quantity or the vendor changes (empty: the vendor's price). */
+        manualPrice: f.decimal({ scale: 2, label: 'Price typed in' }),
+        /** Why the line has its price: the vendor price and its break, or "typed in". */
+        priceReason: f.char({
+            store: true,
+            label: 'Why this price',
+            ...compute('purchase.order.line', 'priceReason', [...PRICE_DEPENDS], async (lines) => {
+                for (const l of lines)
+                    l.priceReason = (await purchaseLinePrice(l)).reason;
+            }),
+        }),
+        /** The vendor's own code for the product, from their price. */
+        vendorCode: f.char({
+            store: true,
+            label: 'Vendor’s code',
+            ...compute('purchase.order.line', 'vendorCode', [...PRICE_DEPENDS], async (lines) => {
+                for (const l of lines)
+                    l.vendorCode = (await purchaseLinePrice(l)).code;
+            }),
+        }),
         /** The line's taxes, applied in order (RFC 0016). */
         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 }),
         datePlanned: f.date({ label: 'Expected arrival' }),
+        acceptanceLines: f.one2many('purchase.work.acceptance.line', 'orderLine'),
+        qtyAccepted: f.decimal({
+            scale: 3,
+            store: true,
+            label: 'Accepted',
+            help: 'What accepted work acceptances cover of this service line.',
+            ...compute('purchase.order.line', 'qtyAccepted', ['acceptanceLines.quantity', 'acceptanceLines.acceptance.state'], (lines) => {
+                for (const l of lines)
+                    l.qtyAccepted = [...l.acceptanceLines]
+                        .filter((a) => a.acceptance.state === 'accepted')
+                        .reduce((s, a) => s.plus(a.quantity), orm.toDecimal(0));
+            }),
+        }),
+        /** The purchase request line this one buys for (RFC 0032 §3.4). */
+        requestLine: f.many2one('purchase.request.line', {
+            ondelete: 'set null',
+            label: 'Request line',
+        }),
         currency: f.many2one('res.currency', {
             store: true,
             ...compute('purchase.order.line', 'currency', ['order.currency'], (lines) => {
@@ -174,6 +371,7 @@ export const PurchaseOrderLine = defineModel('purchase.order.line', {
         subtotal: f.monetary({
             currency: 'currency',
             store: true,
+            help: 'The line’s amount before taxes: the quantity times the unit price, less any tax included in the price.',
             ...compute('purchase.order.line', 'subtotal', [
                 'quantity',
                 'priceUnit',
@@ -193,6 +391,7 @@ export const PurchaseOrderLine = defineModel('purchase.order.line', {
             currency: 'currency',
             store: true,
             label: 'Tax',
+            help: 'The taxes on this line, computed from its amount and its taxes.',
             ...compute('purchase.order.line', 'taxAmount', [
                 'quantity',
                 'priceUnit',
@@ -215,7 +414,6 @@ export const PurchaseOrderLine = defineModel('purchase.order.line', {
             if (p === null)
                 return;
             d.set('name', p.name);
-            d.set('priceUnit', p.standardPrice);
             d.set('uom', p.uom?.id ?? null);
             // The product's taxes, loaded (a draft's related record has its plain fields only).
             const [taxed] = await env
@@ -234,8 +432,16 @@ export const PurchaseOrderLine = defineModel('purchase.order.line', {
 });
 export const purchaseShutro = defineModule({
     name: 'purchase',
-    version: '0.3.0',
+    version: '0.4.0',
     migrations: [
+        {
+            version: '0.4.0',
+            description: 'Vendor prices: existing lines keep the price they have, as typed in (no order is repriced)',
+            up: async (ctx) => {
+                await ctx.sql `UPDATE purchase_order_line SET manual_price = price_unit WHERE manual_price IS NULL`;
+                await ctx.sql `UPDATE purchase_order_line SET price_reason = 'Typed in.' WHERE price_reason IS NULL`;
+            },
+        },
         {
             version: '0.2.0',
             description: 'Several taxes per line: the single tax of each line becomes its first',
@@ -247,10 +453,15 @@ export const purchaseShutro = defineModule({
     ],
     depends: [contactsShutro, productShutro, messagingShutro, permissionsShutro],
     groups: [
+        orm.defineGroup({
+            code: 'purchase.requester',
+            label: 'Purchase requester',
+            implies: ['product.user', 'messaging.user'],
+        }),
         orm.defineGroup({
             code: 'purchase.user',
             label: 'Buyer',
-            implies: ['contacts.user', 'product.user', 'messaging.user'],
+            implies: ['purchase.requester', 'contacts.user', 'product.user', 'messaging.user'],
         }),
         orm.defineGroup({
             code: 'purchase.manager',
@@ -263,6 +474,18 @@ export const purchaseShutro = defineModule({
             implies: ['purchase.manager'],
         }),
     ],
+    permissions: [
+        orm.definePermission({
+            code: 'purchase.request_buy',
+            label: 'Turn purchase requests into requests for quotation',
+            groups: ['purchase.user'],
+        }),
+        orm.definePermission({
+            code: 'purchase.compare_approve',
+            label: 'Approve technical comparisons',
+            groups: ['purchase.manager'],
+        }),
+    ],
     sequences: [
         orm.defineSequence({
             code: 'purchase.order',
@@ -270,7 +493,68 @@ export const purchaseShutro = defineModule({
             padding: 5,
             reset: 'yearly',
         }),
+        orm.defineSequence({
+            code: 'purchase.request',
+            prefix: 'PR/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+        orm.defineSequence({
+            code: 'purchase.tender',
+            prefix: 'RFQ/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+        orm.defineSequence({
+            code: 'purchase.tender.response',
+            prefix: 'RSP/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+        orm.defineSequence({
+            code: 'purchase.comparison',
+            prefix: 'CS/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+        orm.defineSequence({
+            code: 'purchase.technical.comparison',
+            prefix: 'TCS/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+        orm.defineSequence({
+            code: 'purchase.agreement',
+            prefix: 'PA/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+        orm.defineSequence({
+            code: 'purchase.work.acceptance',
+            prefix: 'WA/{year}/',
+            padding: 5,
+            reset: 'yearly',
+        }),
+    ],
+    models: [
+        PurchaseOrder,
+        PurchaseOrderLine,
+        ProductVendorPrice,
+        PurchaseRequest,
+        PurchaseRequestLine,
+        PurchaseTender,
+        PurchaseTenderLine,
+        PurchaseTenderResponse,
+        PurchaseTenderResponseLine,
+        PurchaseTechnicalComparison,
+        PurchaseTechnicalComparisonLine,
+        PurchaseComparison,
+        PurchaseComparisonLine,
+        PurchaseAgreement,
+        PurchaseAgreementLine,
+        PurchaseWorkAcceptance,
+        PurchaseWorkAcceptanceLine,
+        PurchaseVendorRequest,
     ],
-    models: [PurchaseOrder, PurchaseOrderLine],
     extensions: [CompanyPurchase],
 });