shutro-erp 0.3.6 → 0.3.7

package/dist/permissions/index.d.ts

@@ -6,7 +6,7 @@
  */
 import { defineModule } from '../modules-sdk/index.js';
 export { registerAdminApi } from './admin.js';
-export { type ApprovalCard, type ApprovalRequestInfo, approvalCards, approvalGuard, approvalState, approvalStats, approveMany, type Decision, decide, decidersOf, groupsOf, inbox, installApprovalPolicies, issueLinks, linkOf, requestApprovals, requestsOf, sweepDeadlines, turnOf, useLink, type Who, whoIs, withdraw, } from './approvals.js';
+export { APPROVER_KEYS, type ApprovalCard, type ApprovalRequestInfo, approvalCards, approvalGuard, approvalMatrix, approvalState, approvalStats, approveMany, type Decision, decide, decidersOf, eventsOf, groupsOf, inbox, installApprovalPolicies, issueLinks, linkOf, MATRIX_PERIODS, type MatrixCard, type MatrixPeriod, notifyBackups, previewPolicy, reassign, requestApprovals, requestsOf, sweepDeadlines, syncLevels, turnOf, useLink, type Who, whoIs, withdraw, } from './approvals.js';
 export { permissionsShutro } from './models.js';
 export { registerRoleRoutes } from './roles.js';
 export { registerApprovalRoutes } from './routes.js';

package/dist/permissions/index.js

@@ -12,7 +12,7 @@ import { permissionsShutro } from './models.js';
 import { registerRoleRoutes } from './roles.js';
 import { registerApprovalRoutes } from './routes.js';
 export { registerAdminApi } from './admin.js';
-export { approvalCards, approvalGuard, approvalState, approvalStats, approveMany, decide, decidersOf, groupsOf, inbox, installApprovalPolicies, issueLinks, linkOf, requestApprovals, requestsOf, sweepDeadlines, turnOf, useLink, whoIs, withdraw, } from './approvals.js';
+export { APPROVER_KEYS, approvalCards, approvalGuard, approvalMatrix, approvalState, approvalStats, approveMany, decide, decidersOf, eventsOf, groupsOf, inbox, installApprovalPolicies, issueLinks, linkOf, MATRIX_PERIODS, notifyBackups, previewPolicy, reassign, requestApprovals, requestsOf, sweepDeadlines, syncLevels, turnOf, useLink, whoIs, withdraw, } from './approvals.js';
 export { permissionsShutro } from './models.js';
 export { registerRoleRoutes } from './roles.js';
 export { registerApprovalRoutes } from './routes.js';
@@ -29,7 +29,7 @@ export const permissions = defineModule({
     accessLevels: {
         auditor: { label: 'Security auditor', groups: ['permissions.auditor'] },
     },
-    privateModels: ['approval.request', 'approval.vote', 'approval.link'],
+    privateModels: ['approval.request', 'approval.vote', 'approval.link', 'approval.event'],
     hooks: {
         defaults: async (env, modules) => {
             const n = await installApprovalPolicies(env, modules);

package/dist/permissions/models.js

@@ -12,7 +12,11 @@ const modelOf = (env, name) => env.model(name);
 async function readAll(records, keys) {
     const set = records;
     // A many-to-many is loaded by the object spec (defaults plus the relation) and read as ids.
-    const spec = keys.includes('approverUsers') ? { approverUsers: true } : keys;
+    const spec = keys.some((k) => k === 'approverUsers' || k === 'companies')
+        ? Object.fromEntries(keys
+            .filter((k) => ['approverUsers', 'extraUsers', 'backupUsers', 'companies'].includes(k))
+            .map((k) => [k, true]))
+        : keys;
     return set.length === 0 ? [] : (await set.load(spec)).read(keys);
 }
 /** The installed model a policy names, or `undefined`. */
@@ -35,8 +39,16 @@ const ApprovalPolicy = defineModel('approval.policy', {
         name: f.char({ required: true }),
         targetModel: f.char({ required: true, index: true, label: 'Model' }),
         sequence: f.integer({ default: 10 }),
-        /** Empty: every company. */
+        /**
+         * The companies it covers (RFC 0027 §2.3): this company, these companies and every company of this segment
+         * together; all three empty: every company.
+         */
         company: f.many2one('res.company', { ondelete: 'cascade' }),
+        companies: f.many2many('res.company', {
+            relation: 'approval_policy_company_rel',
+            label: 'Companies',
+        }),
+        segment: f.many2one('res.segment', { ondelete: 'restrict', label: 'Segment' }),
         /** A transition of the record run when every level approved (as the system, attributed in the audit log). */
         onApproved: f.char(),
         /** A transition run when a level rejects. */
@@ -47,9 +59,57 @@ const ApprovalPolicy = defineModel('approval.policy', {
         onWithdrawn: f.char({ label: 'On withdrawn' }),
         /** A rejection or a sending back must say why. */
         reasonRequired: f.boolean({ default: true, label: 'Reason required' }),
+        /**
+         * The records the policy is for, as a Shutro domain on the model (RFC 0025 step 4: a request category's policy
+         * covers that category's requests); empty: every record.
+         */
+        condition: f.json({ label: 'For records where' }),
+        /**
+         * When a level finds nobody to decide — no person, and no role to stand in (RFC 0027 §2.4): refuse the submission
+         * and say why, let administrators decide, or skip the level (recorded as skipped).
+         */
+        whenNobody: f.selection({ refuse: 'Refuse the submission', admins: 'Administrators decide', skip: 'Skip the level' }, { required: true, default: 'refuse', label: 'When nobody is found' }),
+        /**
+         * A level whose approvers include someone who already approved this round is approved for them, marked as
+         * such (RFC 0027 §2.2); a level needing more approvals still waits for the others.
+         */
+        skipDuplicates: f.boolean({ default: false, label: 'Skip approvers who already approved' }),
+        /** When a level's approvers change, its waiting requests follow: not, adding the new people, or replacing. */
+        syncPending: f.selection({ off: 'No', add: 'Add the new approvers', replace: 'Replace the approvers' }, { required: true, default: 'add', label: 'Waiting requests follow changes' }),
+        /** Email the people added to a waiting request whose turn it is. */
+        notifyOnSync: f.boolean({ default: true, label: 'Tell the people added' }),
         levels: f.one2many('approval.level', 'policy'),
     },
     constraints: {
+        validCondition: {
+            depends: ['condition', 'targetModel'],
+            check: async (records) => {
+                const { env, ids } = records;
+                return env.asSuperuser({ reason: 'validate approval policy condition' }, async (su) => {
+                    const failing = [];
+                    for (const row of await readAll(modelOf(su, 'approval.policy').browse(ids), [
+                        'condition',
+                        'targetModel',
+                    ])) {
+                        const condition = row['condition'];
+                        if (condition === null || condition === undefined)
+                            continue;
+                        const target = row['targetModel'];
+                        const ok = typeof condition === 'object' &&
+                            !Array.isArray(condition) &&
+                            installed(su, target) &&
+                            (await modelOf(su, String(target))
+                                .search({ where: condition, limit: 1 })
+                                .then(() => true)
+                                .catch(() => false));
+                        if (!ok)
+                            failing.push(row['id']);
+                    }
+                    return failing;
+                });
+            },
+            message: 'The policy’s condition is not a valid domain on its model.',
+        },
         installedModel: {
             depends: ['targetModel'],
             check: async (records) => {
@@ -64,9 +124,60 @@ const ApprovalPolicy = defineModel('approval.policy', {
         },
     },
 });
+/**
+ * A business segment (RFC 0027 §2.3): a group of companies — Feed, Poultry, Dairy — that approval policies cover at
+ * once; a company belongs to one segment.
+ */
+const ResSegment = defineModel('res.segment', {
+    label: 'Segment',
+    recName: 'name',
+    archivable: true,
+    order: ['name asc'],
+    access: { 'base.user': ['read'], 'approvals.manager': ['read', 'write', 'create', 'unlink'] },
+    fields: {
+        name: f.char({ required: true, label: 'Name' }),
+        code: f.char({ label: 'Code' }),
+        /** Its companies; a company is in one segment at most. */
+        companies: f.many2many('res.company', {
+            relation: 'res_segment_company_rel',
+            label: 'Companies',
+        }),
+        note: f.text({ label: 'Note' }),
+    },
+    sqlConstraints: { uniqueName: { unique: ['name'], message: 'Another segment has this name.' } },
+    constraints: {
+        oneSegment: {
+            depends: ['companies', 'active'],
+            check: async (records) => {
+                const { env, ids } = records;
+                return env.asSuperuser({ reason: 'validate segments' }, async (su) => {
+                    const all = await readAll(await modelOf(su, 'res.segment').search({ where: { active: true } }), ['companies']);
+                    const seen = new Map();
+                    const failing = new Set();
+                    for (const row of all)
+                        for (const c of row['companies'] ?? []) {
+                            const other = seen.get(c);
+                            if (other !== undefined) {
+                                if (ids.includes(row['id']))
+                                    failing.add(row['id']);
+                                if (ids.includes(other))
+                                    failing.add(other);
+                            }
+                            else
+                                seen.set(c, row['id']);
+                        }
+                    return [...failing];
+                });
+            },
+            message: 'A company is in one segment at most.',
+        },
+    },
+});
 const ApprovalLevel = defineModel('approval.level', {
     access: { 'base.user': ['read'], 'approvals.manager': ['read', 'write', 'create', 'unlink'] },
     order: ['policy asc', 'sequence asc'],
+    // Waiting requests follow changes of their level's approvers (RFC 0027 §2.6), after the save commits.
+    changeEvents: true,
     fields: {
         policy: f.many2one('approval.policy', { required: true, ondelete: 'cascade' }),
         sequence: f.integer({ default: 10 }),
@@ -81,15 +192,32 @@ const ApprovalLevel = defineModel('approval.level', {
             role: 'A role',
             users: 'Named people',
             manager: 'The requester’s manager',
+            department_head: 'The head of the requester’s department',
+            department_approvers: 'The approvers of the requester’s department',
+            employee: 'A person on the requester’s employee record',
             field: 'A person on the record',
+            record: 'The record decides',
         }, { required: true, default: 'role', label: 'Approved by' }),
+        /** People added to whoever the kind finds (RFC 0027 §2.1). */
+        extraUsers: f.many2many('res.users', {
+            relation: 'approval_level_extra_user_rel',
+            label: 'Also',
+        }),
+        /** Standing backups: may always decide the level beside its approvers (RFC 0027 §2.2). */
+        backupUsers: f.many2many('res.users', {
+            relation: 'approval_level_backup_user_rel',
+            label: 'Backups',
+        }),
         /** The role (or, for a manager or a field, the role used when there is nobody). */
         approverRole: f.char({ label: 'Role' }),
         approverUsers: f.many2many('res.users', {
             relation: 'approval_level_user_rel',
             label: 'People',
         }),
-        /** A many-to-one field of the record to a user (`user`, `project.user`). */
+        /**
+         * A many-to-one field of the record to a user (`user`, `project.user`); for "the record decides", the key passed
+         * to the model's `approvalUsers(key)` (optional).
+         */
         approverField: f.char({ label: 'Field' }),
         /** How many decide: any one, all of them, or a number. */
         quorum: f.selection({ any: 'Any one', all: 'All of them', count: 'A number of them' }, { required: true, default: 'any', label: 'Decided by' }),
@@ -127,7 +255,7 @@ const ApprovalLevel = defineModel('approval.level', {
                         const role = typeof r['approverRole'] === 'string' && r['approverRole'] !== '';
                         const users = Array.isArray(r['approverUsers']) ? r['approverUsers'].length : 0;
                         const kind = r['approverKind'];
-                        return ((kind !== 'users' && !role) ||
+                        return ((kind === 'role' && !role) ||
                             (kind === 'users' && users === 0) ||
                             (kind === 'field' &&
                                 !(typeof r['approverField'] === 'string' && r['approverField'] !== '')) ||
@@ -136,7 +264,7 @@ const ApprovalLevel = defineModel('approval.level', {
                         .map((r) => r['id']);
                 });
             },
-            message: 'A level names its approvers: a role (also the fallback of a manager or a field), people, or a field; a quorum by number needs the number.',
+            message: 'A level names its approvers: a role, people, or a field; a quorum by number needs the number.',
         },
         // A broken condition is refused when saved, not when a user submits a record.
         validCondition: {
@@ -189,6 +317,11 @@ const ApprovalRequest = defineModel('approval.request', {
             relation: 'approval_request_user_rel',
             label: 'Approvers',
         }),
+        /** Backups who may decide it too (from the level). */
+        backups: f.many2many('res.users', {
+            relation: 'approval_request_backup_rel',
+            label: 'Backups',
+        }),
         /** How many approvals it needs. */
         required: f.integer({ required: true, default: 1, label: 'Approvals needed' }),
         /** The submission it belongs to (a resubmission after sending back is the next round). */
@@ -200,6 +333,10 @@ const ApprovalRequest = defineModel('approval.request', {
         /** The role that may also decide since the deadline passed. */
         escalatedTo: f.char({ label: 'Escalated to' }),
         escalatedAt: f.datetime({ label: 'Escalated at' }),
+        /** When the level's turn came (every lower level approved); the deadline counts from it (RFC 0027 §2.5). */
+        startedAt: f.datetime({ label: 'Started' }),
+        /** How its approvers were found, written when it was made. */
+        explanation: f.text({ label: 'How the approvers were found' }),
         state: f.selection({
             pending: 'Pending',
             approved: 'Approved',
@@ -213,6 +350,35 @@ const ApprovalRequest = defineModel('approval.request', {
         comment: f.text(),
     },
 });
+/**
+ * The matrix log (RFC 0027 §2.5): every step of a request — made, its turn, votes, decisions, cancelled, skipped,
+ * reminded, escalated — with who and a note. Private like requests: read through the record's approvals.
+ */
+const ApprovalEvent = defineModel('approval.event', {
+    order: ['at asc', 'id asc'],
+    fields: {
+        request: f.many2one('approval.request', { required: true, ondelete: 'cascade', index: true }),
+        at: f.datetime({ required: true }),
+        user: f.many2one('res.users', { ondelete: 'set null' }),
+        kind: f.selection({
+            created: 'Created',
+            started: 'Its turn',
+            voted: 'Voted',
+            approved: 'Approved',
+            rejected: 'Rejected',
+            sent_back: 'Sent back',
+            cancelled: 'Cancelled',
+            skipped: 'Skipped',
+            reminded: 'Reminded',
+            escalated: 'Escalated',
+            auto: 'Approved already',
+            reassigned: 'Reassigned',
+            synced: 'Synced',
+            notified: 'Backups told',
+        }, { required: true }),
+        note: f.text(),
+    },
+});
 /** One approver's decision on a request (a level decided by several keeps each). */
 const ApprovalVote = defineModel('approval.vote', {
     order: ['request asc', 'at asc', 'id asc'],
@@ -226,6 +392,10 @@ const ApprovalVote = defineModel('approval.vote', {
         onBehalfOf: f.many2one('res.users', { ondelete: 'set null', label: 'For' }),
         /** Decided from an email link: the address it came from. */
         ip: f.char({ label: 'From address' }),
+        /** Copied from the person's approval at an earlier level (skip approvers who already approved). */
+        auto: f.boolean({ default: false, label: 'Approved already' }),
+        /** Decided as one of the level's backups. */
+        asBackup: f.boolean({ default: false, label: 'As backup' }),
     },
     sqlConstraints: {
         once: { unique: ['request', 'user'], message: 'Each approver decides a request once.' },
@@ -311,9 +481,11 @@ export const permissionsShutro = defineModule({
         }),
     ],
     models: [
+        ResSegment,
         ApprovalPolicy,
         ApprovalLevel,
         ApprovalRequest,
+        ApprovalEvent,
         ApprovalVote,
         ApprovalDelegation,
         ApprovalLink,

package/dist/permissions/routes.d.ts

@@ -10,6 +10,9 @@
  * - `GET  /api/v1/approvals/cards?list=inbox|mine|history` the Approvals app's cards (RFC 0025)
  * - `GET  /api/v1/approvals/stats`                       waiting, overdue, decided this month, the median time
  * - `POST /api/v1/approvals/bulk`                        `{ requests, comment? }`: approves each it may
+ * - `POST /api/v1/approvals/requests/:id/reassign`       `{ users, mode: 'replace' | 'add', reason }` (RFC 0027)
+ * - `POST /api/v1/approvals/requests/:id/notify-backups` tells the level's backups it waits (RFC 0027)
+ * - `GET  /api/v1/approvals/matrix?period=&mode=`        the matrix dashboard: cards per policy, direct or delegated
  */
 import { type ModuleContext } from '../server/index.js';
 /** Registers the approval routes. */

package/dist/permissions/routes.js

@@ -10,9 +10,12 @@
  * - `GET  /api/v1/approvals/cards?list=inbox|mine|history` the Approvals app's cards (RFC 0025)
  * - `GET  /api/v1/approvals/stats`                       waiting, overdue, decided this month, the median time
  * - `POST /api/v1/approvals/bulk`                        `{ requests, comment? }`: approves each it may
+ * - `POST /api/v1/approvals/requests/:id/reassign`       `{ users, mode: 'replace' | 'add', reason }` (RFC 0027)
+ * - `POST /api/v1/approvals/requests/:id/notify-backups` tells the level's backups it waits (RFC 0027)
+ * - `GET  /api/v1/approvals/matrix?period=&mode=`        the matrix dashboard: cards per policy, direct or delegated
  */
 import { HttpProblem } from '../server/index.js';
-import { approvalCards, approvalStats, approveMany, decide, inbox, requestsOf, withdraw, } from './approvals.js';
+import { approvalCards, approvalMatrix, approvalStats, approveMany, decide, eventsOf, inbox, MATRIX_PERIODS, notifyBackups, reassign, requestsOf, withdraw, } from './approvals.js';
 function positive(value, what) {
     const id = Number(value);
     if (!Number.isSafeInteger(id) || id <= 0)
@@ -33,7 +36,12 @@ export function registerApprovalRoutes({ app }) {
     app.get('/api/v1/approvals/:model/:id', async (request) => {
         const { model, id } = request.params;
         const recordId = positive(id, 'id');
-        return request.env(async (env) => ({ requests: await requestsOf(env, model, recordId) }), {
+        return request.env(async (env) => ({
+            requests: await requestsOf(env, model, recordId),
+            events: await eventsOf(env, model, recordId),
+            // Approvals managers reassign waiting requests (RFC 0027 §2.6).
+            manage: env.administrator || env.groups.has('approvals.manager'),
+        }), {
             write: true, // reads through audited system scopes
         });
     });
@@ -47,6 +55,32 @@ export function registerApprovalRoutes({ app }) {
             const text = comment(request);
             return request.env(async (env) => decide(env, id, decision, text));
         });
+    // RFC 0027 §2.7: the matrix dashboard.
+    app.get('/api/v1/approvals/matrix', async (request) => {
+        const q = (request.query ?? {});
+        const period = (q.period ?? '3m');
+        if (!MATRIX_PERIODS.includes(period))
+            throw new HttpProblem(400, 'invalid-query', 'Invalid query', `period is one of ${MATRIX_PERIODS.join(', ')}.`);
+        const mode = q.mode === 'delegated' ? 'delegated' : 'direct';
+        return request.env(async (env) => approvalMatrix(env, period, mode), { write: true });
+    });
+    // RFC 0027: reassigning a waiting request; telling its backups.
+    app.post('/api/v1/approvals/requests/:id/reassign', async (request) => {
+        const id = positive(request.params.id, 'id');
+        const body = (request.body ?? {});
+        const users = Array.isArray(body.users) ? body.users.map((u) => positive(u, 'users')) : [];
+        if (body.mode !== undefined && body.mode !== 'replace' && body.mode !== 'add')
+            throw new HttpProblem(400, 'invalid-body', 'Invalid body', "mode is 'replace' or 'add'.");
+        if (typeof body.reason !== 'string' || body.reason.length > 2000)
+            throw new HttpProblem(400, 'invalid-body', 'Invalid body', 'reason is a string (at most 2000).');
+        const mode = body.mode === 'add' ? 'add' : 'replace';
+        const reason = body.reason;
+        return request.env(async (env) => reassign(env, id, users, mode, reason));
+    });
+    app.post('/api/v1/approvals/requests/:id/notify-backups', async (request) => {
+        const id = positive(request.params.id, 'id');
+        return request.env(async (env) => ({ notified: await notifyBackups(env, id) }));
+    });
     // The Approvals app (RFC 0025): its lists, its header, approving many at once.
     app.get('/api/v1/approvals/cards', async (request) => {
         const list = String(request.query?.list ?? 'inbox');

package/dist/permissions/web/ApprovalPanel.js

@@ -10,6 +10,8 @@ import { ApiError, Badge, Button, Textarea } from '../../ui/index.js';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { useId, useState } from 'react';
 import { useTranslation } from 'react-i18next';
+/** Whole hours between two instants (to now when `to` is null). */
+const hoursBetween = (from, to) => Math.max(0, Math.round(((to === null ? Date.now() : Date.parse(to)) - Date.parse(from)) / 3_600_000));
 const TONE = {
     pending: 'warning',
     approved: 'success',
@@ -24,9 +26,11 @@ const DOT = {
     sent_back: 'border-danger bg-danger/40',
     cancelled: 'border-muted-foreground bg-muted',
 };
-function Round({ requests }) {
-    const { t } = useTranslation('approvalPanel');
-    return (_jsx("ol", { className: "grid gap-3", children: requests.map((r) => (_jsxs("li", { className: "flex gap-3 text-sm", children: [_jsx("span", { "aria-hidden": "true", className: `mt-1 size-3 shrink-0 rounded-full border-2 ${DOT[r.state]}` }), _jsxs("span", { className: "grid flex-1 gap-0.5", children: [_jsxs("span", { className: "flex flex-wrap items-center gap-2", children: [_jsx("span", { className: "font-medium", children: r.levelName }), _jsx(Badge, { tone: TONE[r.state], children: t(`state.${r.state}`) }), r.required > 1 ? (_jsx("span", { className: "text-xs text-muted-foreground", children: t('votes', { n: r.approvals, of: r.required }) })) : null] }), r.approverRole === '' ? null : (_jsx("span", { className: "text-xs text-muted-foreground", children: r.approverRole })), r.comment === null ? null : _jsxs("span", { className: "text-xs", children: ["\u201C", r.comment, "\u201D"] })] })] }, r.id))) }));
+function Round({ requests, events = [], }) {
+    const { t, i18n } = useTranslation('approvalPanel');
+    return (_jsx("ol", { className: "grid gap-3", children: requests.map((r) => (_jsxs("li", { className: "flex gap-3 text-sm", children: [_jsx("span", { "aria-hidden": "true", className: `mt-1 size-3 shrink-0 rounded-full border-2 ${DOT[r.state]}` }), _jsxs("span", { className: "grid flex-1 gap-0.5", children: [_jsxs("span", { className: "flex flex-wrap items-center gap-2", children: [_jsx("span", { className: "font-medium", children: r.levelName }), _jsx(Badge, { tone: TONE[r.state], children: t(`state.${r.state}`) }), r.required > 1 ? (_jsx("span", { className: "text-xs text-muted-foreground", children: t('votes', { n: r.approvals, of: r.required }) })) : null] }), r.approverRole === '' ? null : (_jsx("span", { className: "text-xs text-muted-foreground", children: r.approverRole })), r.comment === null ? null : _jsxs("span", { className: "text-xs", children: ["\u201C", r.comment, "\u201D"] }), r.state === 'pending' && r.startedAt !== null ? (_jsx("span", { className: "text-xs text-muted-foreground", children: t('since', { hours: hoursBetween(r.startedAt, null) }) })) : null, r.explanation === null && !events.some((e) => e.request === r.id) ? null : (_jsxs("details", { className: "text-xs text-muted-foreground", children: [_jsx("summary", { className: "cursor-pointer", children: t('how') }), r.explanation === null ? null : _jsx("p", { className: "mt-1", children: r.explanation }), _jsx("ul", { className: "mt-1 grid gap-0.5", "aria-label": t('log'), children: events
+                                        .filter((e) => e.request === r.id)
+                                        .map((e) => (_jsxs("li", { children: [_jsx("time", { dateTime: e.at, children: new Date(e.at).toLocaleString(i18n.language) }), ' ', "\u00B7 ", t(`event.${e.kind}`), e.note === null || e.kind === 'created' ? '' : ` — ${e.note}`] }, e.id))) })] }))] })] }, r.id))) }));
 }
 export function ApprovalPanel({ record, model, api, version, reload, }) {
     const { t } = useTranslation('approvalPanel');
@@ -54,6 +58,32 @@ export function ApprovalPanel({ record, model, api, version, reload, }) {
         mutationFn: ({ request, decision, }) => api.call('POST', `/api/v1/approvals/requests/${request}/${decision}`, comment.trim() === '' ? {} : { comment: comment.trim() }),
         onSuccess: done,
     });
+    const [reassigning, setReassigning] = useState(false);
+    const [chosen, setChosen] = useState([]);
+    const [mode, setMode] = useState('replace');
+    const [reason, setReason] = useState('');
+    const people = useQuery({
+        queryKey: ['approvals', 'people'],
+        queryFn: () => api.call('GET', '/api/v1/models/res.users?fields=id,name&limit=200&order=name'),
+        enabled: reassigning,
+    });
+    const reassign = useMutation({
+        mutationFn: (request) => api.call('POST', `/api/v1/approvals/requests/${request}/reassign`, {
+            users: chosen,
+            mode,
+            reason: reason.trim(),
+        }),
+        onSuccess: async () => {
+            setReassigning(false);
+            setChosen([]);
+            setReason('');
+            await done();
+        },
+    });
+    const tell = useMutation({
+        mutationFn: (request) => api.call('POST', `/api/v1/approvals/requests/${request}/notify-backups`, {}),
+        onSuccess: done,
+    });
     const withdraw = useMutation({
         mutationFn: () => api.call('POST', `/api/v1/approvals/${model}/${recordId}/withdraw`),
         onSuccess: done,
@@ -69,6 +99,14 @@ export function ApprovalPanel({ record, model, api, version, reload, }) {
     const mine = new Set((inbox.data?.requests ?? []).map((r) => r.id));
     const actionable = current.find((r) => mine.has(r.id));
     const asked = current.some((r) => r.state === 'pending' && r.requestedBy === me.data?.id);
-    const error = decide.error ?? withdraw.error;
-    return (_jsxs("section", { "aria-labelledby": `${id}-title`, className: "rounded-lg border bg-surface p-4", children: [_jsxs("h2", { id: `${id}-title`, className: "mb-3 flex items-center gap-2 text-sm font-semibold", children: [t('title'), last > 1 ? _jsx(Badge, { tone: "neutral", children: t('round', { n: last }) }) : null] }), current.length === 0 ? (_jsx("p", { className: "text-sm text-muted-foreground", children: t('withdrawn') })) : (_jsx(Round, { requests: current })), earlier.length === 0 ? null : (_jsxs("details", { className: "mt-3 text-sm", children: [_jsx("summary", { className: "cursor-pointer text-muted-foreground", children: t('earlier', { count: earlier.length }) }), _jsx("div", { className: "mt-2", children: _jsx(Round, { requests: earlier }) })] })), actionable === undefined ? null : (_jsxs("div", { className: "mt-4 grid gap-2", children: [_jsx("label", { htmlFor: `${id}-comment`, className: "text-sm font-medium", children: t('yourDecision', { level: actionable.levelName }) }), _jsx(Textarea, { id: `${id}-comment`, placeholder: t('commentHint'), value: comment, onChange: (e) => setComment(e.target.value) }), _jsxs("div", { className: "flex flex-wrap gap-2", children: [_jsx(Button, { variant: "primary", disabled: decide.isPending, onClick: () => decide.mutate({ request: actionable.id, decision: 'approve' }), children: t('approve') }), _jsx(Button, { disabled: decide.isPending || comment.trim() === '', onClick: () => decide.mutate({ request: actionable.id, decision: 'send-back' }), children: t('sendBack') }), _jsx(Button, { variant: "danger", disabled: decide.isPending || comment.trim() === '', onClick: () => decide.mutate({ request: actionable.id, decision: 'reject' }), children: t('reject') })] })] })), asked ? (_jsx("div", { className: "mt-3", children: _jsx(Button, { variant: "ghost", disabled: withdraw.isPending, onClick: () => withdraw.mutate(), children: t('withdraw') }) })) : null, error === null ? null : (_jsx("p", { role: "alert", className: "mt-2 text-sm text-danger", children: error instanceof ApiError ? error.message : String(error) }))] }));
+    const error = decide.error ?? withdraw.error ?? reassign.error ?? tell.error;
+    const manage = requests.data?.manage === true;
+    // The waiting request whose turn it is (the first, when levels decide side by side).
+    const waiting = current.find((r) => r.state === 'pending' && r.startedAt !== null);
+    const mayTell = waiting !== undefined &&
+        waiting.backups.length > 0 &&
+        (manage || waiting.approvers.includes(me.data?.id ?? -1));
+    return (_jsxs("section", { "aria-labelledby": `${id}-title`, className: "rounded-lg border bg-surface p-4", children: [_jsxs("h2", { id: `${id}-title`, className: "mb-3 flex items-center gap-2 text-sm font-semibold", children: [t('title'), last > 1 ? _jsx(Badge, { tone: "neutral", children: t('round', { n: last }) }) : null] }), current.length === 0 ? (_jsx("p", { className: "text-sm text-muted-foreground", children: t('withdrawn') })) : (_jsx(Round, { requests: current, events: requests.data?.events ?? [] })), earlier.length === 0 ? null : (_jsxs("details", { className: "mt-3 text-sm", children: [_jsx("summary", { className: "cursor-pointer text-muted-foreground", children: t('earlier', { count: earlier.length }) }), _jsx("div", { className: "mt-2", children: _jsx(Round, { requests: earlier }) })] })), actionable === undefined ? null : (_jsxs("div", { className: "mt-4 grid gap-2", children: [_jsx("label", { htmlFor: `${id}-comment`, className: "text-sm font-medium", children: t('yourDecision', { level: actionable.levelName }) }), _jsx(Textarea, { id: `${id}-comment`, placeholder: t('commentHint'), value: comment, onChange: (e) => setComment(e.target.value) }), _jsxs("div", { className: "flex flex-wrap gap-2", children: [_jsx(Button, { variant: "primary", disabled: decide.isPending, onClick: () => decide.mutate({ request: actionable.id, decision: 'approve' }), children: t('approve') }), _jsx(Button, { disabled: decide.isPending || comment.trim() === '', onClick: () => decide.mutate({ request: actionable.id, decision: 'send-back' }), children: t('sendBack') }), _jsx(Button, { variant: "danger", disabled: decide.isPending || comment.trim() === '', onClick: () => decide.mutate({ request: actionable.id, decision: 'reject' }), children: t('reject') })] })] })), waiting !== undefined && (manage || mayTell) ? (_jsxs("div", { className: "mt-3 flex flex-wrap gap-2", children: [manage ? (_jsx(Button, { variant: "ghost", onClick: () => setReassigning((v) => !v), children: t('reassign') })) : null, mayTell ? (_jsx(Button, { variant: "ghost", disabled: tell.isPending, onClick: () => tell.mutate(waiting.id), children: t('tellBackups') })) : null] })) : null, reassigning && waiting !== undefined ? (_jsxs("fieldset", { className: "mt-3 grid gap-2 rounded-md border p-3", children: [_jsx("legend", { className: "px-1 text-sm font-medium", children: t('reassignLevel', { level: waiting.levelName }) }), _jsx("label", { htmlFor: `${id}-people`, className: "text-sm", children: t('newApprovers') }), _jsx("select", { id: `${id}-people`, multiple: true, className: "min-h-24 rounded-md border bg-surface p-1 text-sm", value: chosen.map(String), onChange: (e) => setChosen([...e.target.selectedOptions].map((o) => Number(o.value))), children: (people.data?.items ?? [])
+                            .filter((u) => u.id !== waiting.requestedBy)
+                            .map((u) => (_jsx("option", { value: u.id, children: u.name }, u.id))) }), _jsx("div", { className: "flex flex-wrap gap-3 text-sm", children: ['replace', 'add'].map((m) => (_jsxs("label", { className: "flex items-center gap-1", children: [_jsx("input", { type: "radio", name: `${id}-mode`, checked: mode === m, onChange: () => setMode(m) }), t(`mode.${m}`)] }, m))) }), _jsx("label", { htmlFor: `${id}-reason`, className: "text-sm", children: t('reason') }), _jsx(Textarea, { id: `${id}-reason`, value: reason, onChange: (e) => setReason(e.target.value) }), _jsx("div", { children: _jsx(Button, { variant: "primary", disabled: reassign.isPending || chosen.length === 0 || reason.trim() === '', onClick: () => reassign.mutate(waiting.id), children: t('reassignConfirm') }) })] })) : null, asked ? (_jsx("div", { className: "mt-3", children: _jsx(Button, { variant: "ghost", disabled: withdraw.isPending, onClick: () => withdraw.mutate(), children: t('withdraw') }) })) : null, error === null ? null : (_jsx("p", { role: "alert", className: "mt-2 text-sm text-danger", children: error instanceof ApiError ? error.message : String(error) }))] }));
 }

package/dist/permissions/web/messages.js

@@ -12,6 +12,32 @@ export const messages = {
         sendBack: 'Send back for changes',
         reject: 'Reject',
         withdraw: 'Withdraw my request',
+        how: 'How the approvers were found',
+        reassign: 'Reassign',
+        reassignLevel: 'Reassign {{level}}',
+        newApprovers: 'Who decides instead',
+        mode: { replace: 'Replace the approvers', add: 'Add to them' },
+        reason: 'Why (required)',
+        reassignConfirm: 'Reassign',
+        tellBackups: 'Tell the backups',
+        log: 'Log',
+        since: 'Its turn for {{hours}} h',
+        event: {
+            created: 'Created',
+            started: 'Its turn',
+            voted: 'Voted',
+            approved: 'Approved',
+            rejected: 'Rejected',
+            sent_back: 'Sent back',
+            cancelled: 'Cancelled',
+            skipped: 'Skipped',
+            reminded: 'Reminded',
+            escalated: 'Escalated',
+            auto: 'Approved already',
+            reassigned: 'Reassigned',
+            synced: 'Synced',
+            notified: 'Backups told',
+        },
         state: {
             pending: 'Waiting',
             approved: 'Approved',
@@ -32,6 +58,32 @@ export const messages = {
         sendBack: 'সংশোধনের জন্য ফেরত',
         reject: 'প্রত্যাখ্যান',
         withdraw: 'আমার অনুরোধ প্রত্যাহার',
+        how: 'অনুমোদনকারী কীভাবে নির্ধারিত হলেন',
+        reassign: 'অন্যকে দিন',
+        reassignLevel: '{{level}} অন্যকে দিন',
+        newApprovers: 'এর বদলে কে সিদ্ধান্ত নেবেন',
+        mode: { replace: 'অনুমোদনকারী বদলে দিন', add: 'তাঁদের সঙ্গে যোগ করুন' },
+        reason: 'কারণ (আবশ্যক)',
+        reassignConfirm: 'অন্যকে দিন',
+        tellBackups: 'বিকল্পদের জানান',
+        log: 'লগ',
+        since: '{{hours}} ঘণ্টা ধরে এর পালা',
+        event: {
+            created: 'তৈরি',
+            started: 'এর পালা',
+            voted: 'ভোট',
+            approved: 'অনুমোদিত',
+            rejected: 'প্রত্যাখ্যাত',
+            sent_back: 'ফেরত পাঠানো',
+            cancelled: 'বাতিল',
+            skipped: 'বাদ দেওয়া',
+            reminded: 'মনে করানো',
+            escalated: 'ঊর্ধ্বতনে পাঠানো',
+            auto: 'আগেই অনুমোদিত',
+            reassigned: 'অন্যকে দেওয়া',
+            synced: 'মিলিয়ে নেওয়া',
+            notified: 'বিকল্পদের জানানো',
+        },
         state: {
             pending: 'অপেক্ষায়',
             approved: 'অনুমোদিত',

package/dist/portal/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: d1428de5985e3529
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: ebc3fbac95760b14
 // Bindings of module `portal`: 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';

package/dist/portal/.kosh/schema.d.ts

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: d1428de5985e3529
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: ebc3fbac95760b14
 // Schema view of module `portal` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -508,6 +508,7 @@ export interface ResPartner {
     readonly parent: F.Many2one<'res.partner'>;
     readonly contacts: F.One2many<'res.partner', { readonly required: true }>;
     readonly email: F.Char;
+    readonly lang: F.Selection<'en' | 'bn'>;
     readonly phone: F.Char;
     readonly mobile: F.Char;
     readonly website: F.Char;

package/dist/portal/documents.d.ts

@@ -12,6 +12,9 @@ export interface PortalDocument {
     readonly model: ApiModel;
     /** The lines' model, when the document has lines. */
     readonly lineModel: ApiModel | null;
+    /** The optional items' model and the field that points back at the document, when it has options. */
+    readonly optionModel: ApiModel | null;
+    readonly optionParent: string | null;
 }
 /** The documents of the loaded modules, by key. @throws {ServerConfigError} for a declaration that cannot work */
 export declare function portalDocuments(registry: KoshRegistry): ReadonlyMap<string, PortalDocument>;

package/dist/portal/documents.js

@@ -50,12 +50,32 @@ export function portalDocuments(registry) {
                     if (!lineModel.byKey.has(field))
                         fail(key, `${lines?.target} has no field '${field}'.`, 'Declare existing line fields.');
             }
+            let optionModel = null;
+            let optionParent = null;
+            if (spec.options !== undefined) {
+                const options = m.byKey.get(spec.options.field);
+                if (options?.kind !== 'one2many' || options.target === null)
+                    fail(key, `'${spec.options.field}' is not a one2many.`, 'Name the options field.');
+                optionModel = models.get(options?.target ?? '') ?? null;
+                if (optionModel === null)
+                    fail(key, `the options' model ${options?.target} is not served.`, 'Use a served model.');
+                const om = optionModel;
+                for (const field of spec.options.fields)
+                    if (!om.byKey.has(field))
+                        fail(key, `${om.name} has no field '${field}'.`, 'Declare existing option fields.');
+                if (!om.transitions.includes(spec.options.add))
+                    fail(key, `${om.name} has no transition '${spec.options.add}'.`, 'Name the transition that adds an option.');
+                optionParent =
+                    om.fields.find((f) => f.kind === 'many2one' && f.target === spec.model)?.key ?? null;
+                if (optionParent === null)
+                    fail(key, `${om.name} has no many2one to ${spec.model}.`, 'Options point at their document.');
+            }
             for (const action of spec.actions ?? [])
                 if (!m.transitions.includes(action.transition))
                     fail(key, `${spec.model} has no transition '${action.transition}' (action '${action.key}').`, `Transitions: ${m.transitions.join(', ') || 'none'}.`);
             if (spec.pdf !== undefined && !templates.has(spec.pdf))
                 fail(key, `no document template '${spec.pdf}'.`, 'Name a template a module ships (module.key).');
-            out.set(key, { spec, model: m, lineModel });
+            out.set(key, { spec, model: m, lineModel, optionModel, optionParent });
         }
     return out;
 }

package/dist/portal/i18n/bn.d.ts

@@ -0,0 +1,2 @@
+/** Bangla for the module's labels, keyed by their English text (RFC 0023 §3.1; `pnpm i18n:extract`). */
+export declare const bn: Readonly<Record<string, string>>;