shutro-erp 0.3.6 → 0.3.7

package/dist/mail/send.js

@@ -0,0 +1,394 @@
+/**
+ * Sending documents (RFC 0029 §3.3). Modules declare email templates (`mailTemplates`) and the documents sent from
+ * their form (`sendable`: the template and the partner field). The Send dialog asks for the composition — the
+ * partner's address, the template's subject and body filled in the partner's language, the PDF named — and sends
+ * it, edited or not: the PDF is rendered and stored on the record, the message posted on its chatter with it, and
+ * the email queued in `mail.outgoing` and sent by an outbox subscriber, so a failed send never undoes the record.
+ */
+import { chatterContext, postMessage } from '../messaging/index.js';
+import { documentFields, fillText, loadDocumentData, renderDocument, } from '../reporting/index.js';
+import { HttpProblem, publicApiModels } from '../server/index.js';
+import { orm } from '../server/orm.js';
+import { openAttachment, saveAttachment, storageOf } from '../storage/index.js';
+import { escapeHtml, layout } from './index.js';
+const { defineModel, f } = orm;
+/** An email template (RFC 0029 §3.3): installed from manifests by key, edited by Email managers. */
+const MailTemplate = defineModel('mail.template', {
+    label: 'Email template',
+    archivable: true,
+    order: ['targetModel asc', 'name asc'],
+    access: {
+        'base.user': ['read'],
+        'mail.manager': ['read', 'write', 'create', 'unlink'],
+    },
+    fields: {
+        name: f.char({ required: true, translate: true, label: 'Template' }),
+        targetModel: f.char({ required: true, index: true, label: 'Document' }),
+        /** `module.key` of the manifest template it came from, so reinstalls do not duplicate it. */
+        key: f.char({ index: 'unique' }),
+        subject: f.char({ required: true, translate: true, size: 998, label: 'Subject' }),
+        body: f.text({
+            required: true,
+            translate: true,
+            label: 'Body',
+            help: 'Plain text with {{field}} placeholders (name, partner.name, amountTotal, company.name); a blank line starts a paragraph.',
+        }),
+        document: f.char({
+            label: 'Attach the document',
+            help: 'The document template sent as a PDF, as module.key (accounting.invoice); empty: no attachment.',
+        }),
+    },
+});
+/** An email sent from a record (RFC 0029 §3.3): queued with the record, sent by the outbox subscriber. */
+const MailOutgoing = defineModel('mail.outgoing', {
+    label: 'Sent email',
+    order: ['id desc'],
+    access: { 'mail.manager': ['read'] },
+    indexes: [{ fields: ['resModel', 'resId'] }, { fields: ['state'] }],
+    fields: {
+        resModel: f.char({ required: true, label: 'Document' }),
+        resId: f.integer({ required: true, label: 'Record' }),
+        to: f.text({ required: true, label: 'To' }),
+        cc: f.text({ label: 'Cc' }),
+        subject: f.char({ required: true, size: 998, label: 'Subject' }),
+        text: f.text({ label: 'Text' }),
+        html: f.text({ label: 'HTML' }),
+        attachments: f.many2many('storage.attachment', {
+            relation: 'mail_outgoing_attachment_rel',
+            label: 'Attachments',
+        }),
+        state: f.selection({ queued: 'Queued', sent: 'Sent', failed: 'Failed' }, {
+            required: true,
+            default: 'queued',
+            label: 'Status',
+            help: 'Queued until the mail server took it; failed with the reason when it refused.',
+        }),
+        error: f.text({ label: 'Error' }),
+        providerId: f.char({ size: 998, label: 'Message id' }),
+        sentAt: f.datetime({ label: 'Sent' }),
+        author: f.many2one('res.users', { ondelete: 'set null', label: 'Sent by' }),
+        message: f.many2one('mail.message', { ondelete: 'set null', label: 'Chatter message' }),
+    },
+});
+/** The models of sending documents, added to the mail module's. */
+export const SEND_MODELS = [MailTemplate, MailOutgoing];
+/** The sendable documents of the loaded modules, by model. */
+export function sendablesOf(modules) {
+    const out = new Map();
+    for (const m of modules)
+        for (const s of m.sendable ?? [])
+            out.set(s.model, s);
+    return out;
+}
+/** Installs the manifests' email templates that do not exist yet (by `module.key`). */
+export async function installMailTemplates(env, modules) {
+    let created = 0;
+    const model = env.withFlags({ activeTest: false }).model('mail.template');
+    for (const m of modules)
+        for (const spec of m.mailTemplates ?? []) {
+            const key = `${m.name}.${spec.key}`;
+            if ((await model.search({ where: { key } })).length > 0)
+                continue;
+            const translations = Object.entries(spec.translations ?? {});
+            await model.create([
+                {
+                    name: spec.name,
+                    targetModel: spec.model,
+                    key,
+                    subject: {
+                        en_US: spec.subject,
+                        ...Object.fromEntries(translations.map(([l, t]) => [l, t.subject])),
+                    },
+                    body: {
+                        en_US: spec.body,
+                        ...Object.fromEntries(translations.map(([l, t]) => [l, t.body])),
+                    },
+                    ...(spec.document === undefined ? {} : { document: spec.document }),
+                },
+            ]);
+            created++;
+        }
+    return created;
+}
+const LANGS = { en: 'en_US', bn: 'bn_BD' };
+const EMAIL = /^[^\s@<>,;]+@[^\s@<>,;]+\.[^\s@<>,;]+$/;
+/** A list of addresses from the body: each checked, at most 20. */
+function addresses(value, what) {
+    const list = Array.isArray(value)
+        ? value
+        : typeof value === 'string'
+            ? value.split(/[,;]/)
+            : value === undefined || value === null
+                ? []
+                : null;
+    if (list === null)
+        throw bad(`${what} is a list of email addresses.`);
+    const out = list.map((a) => String(a).trim()).filter((a) => a !== '');
+    if (out.length > 20)
+        throw bad(`At most 20 addresses in ${what}.`);
+    const wrong = out.find((a) => !EMAIL.test(a));
+    if (wrong !== undefined)
+        throw bad(`${wrong} is not an email address.`);
+    return out;
+}
+const bad = (detail) => new HttpProblem(400, 'invalid-body', 'Invalid email', detail);
+const ref = (env, name) => env.model(name);
+/** The send engine of one server: the sendable documents, the models' metadata, the mailer. */
+export function sendEngine(context, mailer) {
+    const apiModels = publicApiModels(context.registry);
+    const fields = documentFields(apiModels);
+    const modules = context.registry.loaded.modules;
+    const sendables = sendablesOf(modules);
+    const chatter = chatterContext(context);
+    const served = new Set(apiModels.keys());
+    const reporting = modules.some((m) => m.name === 'reporting');
+    /** The record as the caller, matching the document's `when`; refused otherwise. */
+    const sendable = async (env, model, id) => {
+        const spec = sendables.get(model);
+        if (spec === undefined)
+            throw new HttpProblem(404, 'not-sendable', 'Not sent by email', `${model} is not sendable.`);
+        const found = await ref(env, model).search({
+            where: { id, ...(spec.when ?? {}) },
+            limit: 1,
+        });
+        if (found.length === 0) {
+            const exists = (await ref(env, model).search({ where: { id }, limit: 1 })).length > 0;
+            if (!exists)
+                throw new HttpProblem(404, 'missing-record', 'Not found', 'No such record.');
+            throw new HttpProblem(409, 'not-ready', 'Not ready to send', 'This document cannot be sent in its state.');
+        }
+        return spec;
+    };
+    const templateOf = async (env, key) => {
+        const [row] = (await (await ref(env, 'mail.template').search({ where: { key }, limit: 1 })).load([])).read(['id', 'subject', 'body', 'document']);
+        if (row === undefined)
+            throw new HttpProblem(409, 'no-template', 'No email template', `The template ${key} is missing or archived: run the apps' defaults, or restore it.`);
+        return row;
+    };
+    /** The partner's name, address and language. */
+    const partnerOf = async (env, spec, model, id) => {
+        const [record] = (await ref(env, model).browse([id]).load([spec.partner])).read([spec.partner]);
+        const value = record?.[spec.partner];
+        const partnerId = typeof value === 'number' ? value : (value?.id ?? null);
+        if (partnerId === null)
+            return null;
+        const hasLang = apiModels.get('res.partner')?.fields.some((f) => f.key === 'lang') === true;
+        const keys = ['name', 'email', ...(hasLang ? ['lang'] : [])];
+        const [p] = (await ref(env, 'res.partner').browse([partnerId]).load(keys)).read(keys);
+        return p === undefined
+            ? null
+            : {
+                name: String(p['name'] ?? ''),
+                email: p['email'] ?? null,
+                lang: p['lang'] ?? null,
+            };
+    };
+    /** The subject and body filled for the record, in `lang`. */
+    const fill = async (env, model, id, subject, body) => {
+        const layout = {
+            paper: 'A4',
+            blocks: [{ kind: 'text', id: 'mail', text: `${subject}\n${body}` }],
+        };
+        const data = await loadDocumentData(env, model, [id], layout, fields);
+        const lang = env.lang.replace('_', '-');
+        const doc = {
+            model,
+            record: data.records[0] ?? {},
+            company: data.company,
+            user: data.user,
+            now: new Date(),
+            locale: lang,
+            tz: env.tz,
+        };
+        return { subject: fillText(doc, fields, subject), body: fillText(doc, fields, body) };
+    };
+    /** The partner's language (`bn`, `en`, or a full code like `bn_BD`) as the environment's. */
+    const languageOf = (env, lang) => {
+        const full = lang === null || lang === '' ? null : (LANGS[lang] ?? lang);
+        try {
+            return full === null ? env : env.withLang(full);
+        }
+        catch {
+            return env;
+        }
+    };
+    async function compose(env, model, id) {
+        const spec = await sendable(env, model, id);
+        const partner = await partnerOf(env, spec, model, id);
+        const local = languageOf(env, partner?.lang ?? null);
+        const template = await templateOf(local, spec.template);
+        const filled = await fill(local, model, id, String(template['subject'] ?? ''), String(template['body'] ?? ''));
+        const document = template['document'] ?? null;
+        // How often it was sent: counted directly (the caller reads the record; the log itself is for Email managers).
+        const [sent] = await env.sql `
+      SELECT count(*)::int AS count, max(created_at) AS last FROM mail_outgoing
+      WHERE res_model = ${model} AND res_id = ${id} AND state <> 'failed'`;
+        return {
+            to: partner === null ? [] : [{ name: partner.name, email: partner.email }],
+            ...filled,
+            attachment: document !== null && reporting ? `${await nameOf(env, model, id)}.pdf` : null,
+            lang: local.lang,
+            sent: sent?.count ?? 0,
+            lastSentAt: sent?.last instanceof Date ? sent.last.toISOString() : null,
+        };
+    }
+    const nameOf = async (env, model, id) => {
+        const [row] = (await ref(env, model).browse([id]).load(['displayName'])).read(['displayName']);
+        return String(row?.['displayName'] ?? `${model}-${id}`).replace(/[\\/:*?"<>|]+/g, '-');
+    };
+    async function send(env, model, id, input) {
+        const spec = await sendable(env, model, id);
+        if (mailer() === undefined)
+            throw new HttpProblem(409, 'no-mailer', 'No email set up', 'Set SMTP_URL to send documents by email.');
+        const to = addresses(input.to, 'to');
+        const cc = addresses(input.cc, 'cc');
+        if (to.length === 0)
+            throw bad('Name at least one recipient.');
+        const subject = typeof input.subject === 'string' ? input.subject.trim() : '';
+        const body = typeof input.body === 'string' ? input.body.trim() : '';
+        if (subject === '' || subject.length > 998)
+            throw bad('The subject is 1 to 998 characters.');
+        if (body.length > 50_000)
+            throw bad('The body is at most 50,000 characters.');
+        const template = await templateOf(env, spec.template);
+        const documentKey = template['document'] ?? null;
+        let attachment = null;
+        if (input.attach !== false && documentKey !== null && reporting) {
+            const [doc] = (await (await ref(env, 'report.template').search({ where: { key: documentKey }, limit: 1 })).load([])).read(['id', 'name', 'layout', 'scope']);
+            const apiModel = apiModels.get(model);
+            if (doc !== undefined && apiModel !== undefined) {
+                const rendered = await renderDocument(env, apiModel, doc, fields, { ids: [id] }, 'pdf');
+                const saved = await saveAttachment(env, storageOf(context.app), served, {
+                    model,
+                    id,
+                    name: `${await nameOf(env, model, id)}.pdf`,
+                    mime: 'application/pdf',
+                    data: rendered.content,
+                });
+                attachment = saved.id;
+            }
+        }
+        const posted = await postMessage(env, chatter, model, id, {
+            kind: 'comment',
+            text: `${subject}\n\n${body}`,
+            attachments: attachment === null ? [] : [attachment],
+        });
+        const paragraphs = body
+            .split(/\n\s*\n/)
+            .map((p) => p.trim())
+            .filter((p) => p !== '');
+        const mail = layout({ title: subject, paragraphs, lang: env.lang.slice(0, 2) });
+        const outgoing = await env.asSuperuser({ reason: 'email queued from a record' }, async (su) => {
+            const made = await ref(su, 'mail.outgoing').create([
+                {
+                    resModel: model,
+                    resId: id,
+                    to: to.join(', '),
+                    cc: cc.length === 0 ? null : cc.join(', '),
+                    subject,
+                    text: body,
+                    html: mail.html,
+                    attachments: { set: attachment === null ? [] : [attachment] },
+                    author: env.uid,
+                    message: posted.id,
+                },
+            ]);
+            return made.ids[0];
+        });
+        await env.emit('mail.outgoing.queued', { outgoing, model, id });
+        return { outgoing, message: posted.id, attachment };
+    }
+    /** Sends one queued email, as the system (the outbox subscriber). Sent once: a sent row is left alone. */
+    async function deliver(su, outgoing) {
+        const [row] = (await ref(su, 'mail.outgoing').browse([outgoing]).load({ attachments: true })).read(['to', 'cc', 'subject', 'text', 'html', 'state', 'attachments']);
+        const m = mailer();
+        if (row === undefined || row['state'] !== 'queued' || m === undefined)
+            return;
+        try {
+            const files = [];
+            for (const a of (row['attachments'] ?? [])) {
+                const opened = await openAttachment(su, storageOf(context.app), served, typeof a === 'number' ? a : a.id);
+                const chunks = [];
+                for await (const chunk of opened.body)
+                    chunks.push(Buffer.from(chunk));
+                files.push({
+                    filename: opened.info.name,
+                    content: Buffer.concat(chunks),
+                    contentType: opened.info.mime,
+                });
+            }
+            const cc = String(row['cc'] ?? '')
+                .split(',')
+                .map((a) => a.trim())
+                .filter((a) => a !== '');
+            const result = await m.send({
+                to: String(row['to']),
+                ...(cc.length === 0 ? {} : { cc }),
+                subject: String(row['subject']),
+                text: String(row['text'] ?? ''),
+                html: String(row['html'] ?? escapeHtml(String(row['text'] ?? ''))),
+                ...(files.length === 0 ? {} : { attachments: files }),
+            });
+            await ref(su, 'mail.outgoing')
+                .browse([outgoing])
+                .write({ state: 'sent', sentAt: new Date(), providerId: result.id });
+        }
+        catch (error) {
+            await ref(su, 'mail.outgoing')
+                .browse([outgoing])
+                .write({
+                state: 'failed',
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /** The composition sent as it is, to the partner's address; refused (before any write) when it cannot be. */
+    async function sendComposed(env, model, id) {
+        const c = await compose(env, model, id);
+        const to = c.to.map((r) => r.email).filter((e) => e !== null && e !== '');
+        if (to.length === 0)
+            throw new HttpProblem(409, 'no-address', 'No email address', `${c.to[0]?.name ?? 'The partner'} has no email address.`);
+        return send(env, model, id, { to, subject: c.subject, body: c.body });
+    }
+    async function sendMany(env, model, ids) {
+        if (ids.length === 0 || ids.length > 100)
+            throw new HttpProblem(400, 'invalid-body', 'Invalid batch', 'Send 1 to 100 records at once.');
+        let sent = 0;
+        const skipped = [];
+        for (const id of ids)
+            try {
+                await sendComposed(env, model, id);
+                sent++;
+            }
+            catch (error) {
+                // Refusals happen before anything is written (the record, its state, its address): the batch goes on.
+                if (!(error instanceof HttpProblem) || error.problem.status >= 500)
+                    throw error;
+                skipped.push({ id, reason: error.problem.detail ?? error.problem.title });
+            }
+        return { sent, skipped };
+    }
+    async function autoSend(env, model, id) {
+        const spec = sendables.get(model);
+        if (spec?.autoSend === undefined || mailer() === undefined)
+            return false;
+        const found = await ref(env, model).search({ where: { id, ...(spec.when ?? {}) }, limit: 1 });
+        if (found.length === 0)
+            return false;
+        const [record] = (await ref(env, model).browse([id]).load([spec.partner])).read([spec.partner]);
+        const value = record?.[spec.partner];
+        const partner = typeof value === 'number' ? value : (value?.id ?? null);
+        if (partner === null)
+            return false;
+        const flag = spec.autoSend.flag;
+        const [p] = (await ref(env, 'res.partner').browse([partner]).load([flag, 'email'])).read([
+            flag,
+            'email',
+        ]);
+        if (p?.[flag] !== true || typeof p['email'] !== 'string' || p['email'] === '')
+            return false;
+        await sendComposed(env, model, id);
+        return true;
+    }
+    return { sendables, compose, send, deliver, sendMany, autoSend };
+}

package/dist/mail/web/SendButton.d.ts

@@ -0,0 +1,9 @@
+/**
+ * "Send" on the form of a sendable document (RFC 0029 §3.3): the dialog opens with the customer's address, the
+ * template's subject and body in their language and the PDF named; everything can be edited before sending. The
+ * server renders the PDF, posts the message on the chatter and queues the email. Hidden on documents that are not
+ * sendable, and refused by the server on records not ready to send.
+ */
+import { type NodeComponentProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function SendButton({ record, model, api, reload, }: NodeComponentProps): ReactElement | null;

package/dist/mail/web/SendButton.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * "Send" on the form of a sendable document (RFC 0029 §3.3): the dialog opens with the customer's address, the
+ * template's subject and body in their language and the PDF named; everything can be edited before sending. The
+ * server renders the PDF, posts the message on the chatter and queues the email. Hidden on documents that are not
+ * sendable, and refused by the server on records not ready to send.
+ */
+import { ApiError, Button, Checkbox, Dialog, Input, Label, Textarea, useKosh, } from '../../ui/index.js';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { Mail, Paperclip } from 'lucide-react';
+import { useId, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+export function SendButton({ record, model, api, reload, }) {
+    const { t } = useTranslation('mail');
+    const { format } = useKosh();
+    const id = useId();
+    const queryClient = useQueryClient();
+    const [open, setOpen] = useState(false);
+    const [to, setTo] = useState('');
+    const [cc, setCc] = useState('');
+    const [subject, setSubject] = useState('');
+    const [body, setBody] = useState('');
+    const [attach, setAttach] = useState(true);
+    const [done, setDone] = useState(false);
+    const sendable = useQuery({
+        queryKey: ['mail', 'sendable'],
+        queryFn: () => api.call('GET', '/api/v1/mail/sendable'),
+        staleTime: Number.POSITIVE_INFINITY,
+    });
+    const compose = useMutation({
+        mutationFn: () => api.call('GET', `/api/v1/mail/compose/${model}/${record?.id}`),
+        onSuccess: (c) => {
+            setTo(c.to
+                .map((r) => r.email)
+                .filter((e) => e !== null && e !== '')
+                .join(', '));
+            setCc('');
+            setSubject(c.subject);
+            setBody(c.body);
+            setAttach(c.attachment !== null);
+            setDone(false);
+            setOpen(true);
+        },
+    });
+    const send = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/mail/send/${model}/${record?.id}`, {
+            to,
+            cc,
+            subject,
+            body,
+            attach,
+        }),
+        onSuccess: () => {
+            setDone(true);
+            setOpen(false);
+            // The message is on the chatter now.
+            void queryClient.invalidateQueries({ queryKey: ['chatter', model, record?.id] });
+            reload?.();
+        },
+    });
+    if (record === null || !(sendable.data?.models ?? []).includes(model))
+        return null;
+    const c = compose.data;
+    const error = compose.error ?? send.error;
+    return (_jsxs("div", { className: "flex items-center gap-2", children: [_jsxs(Button, { size: "sm", busy: compose.isPending, onClick: () => compose.mutate(), children: [_jsx(Mail, { "aria-hidden": true }), t('send.button')] }), done ? (_jsx("span", { role: "status", className: "text-xs text-muted-foreground", children: t('send.queued') })) : null, error !== null && !open ? (_jsx("span", { role: "alert", className: "text-xs text-danger", children: error instanceof ApiError ? error.message : String(error) })) : null, _jsx(Dialog, { open: open, onOpenChange: setOpen, title: t('send.title'), description: c === undefined || c.sent === 0
+                    ? t('send.intro')
+                    : t('send.already', {
+                        count: c.sent,
+                        date: c.lastSentAt === null ? '' : format.date(c.lastSentAt),
+                    }), footer: _jsx(Button, { variant: "primary", busy: send.isPending, disabled: to.trim() === '' || subject.trim() === '', onClick: () => send.mutate(), children: t('send.confirm') }), children: _jsxs("div", { className: "space-y-3", children: [_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-to`, children: t('send.to') }), _jsx(Input, { id: `${id}-to`, type: "text", value: to, onChange: (e) => setTo(e.target.value) }), c?.to.some((r) => r.email === null || r.email === '') ? (_jsx("p", { className: "text-xs text-muted-foreground", children: t('send.noEmail', { name: c.to[0]?.name ?? '' }) })) : null] }), _jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-cc`, children: t('send.cc') }), _jsx(Input, { id: `${id}-cc`, type: "text", value: cc, onChange: (e) => setCc(e.target.value) })] }), _jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-subject`, children: t('send.subject') }), _jsx(Input, { id: `${id}-subject`, value: subject, maxLength: 998, onChange: (e) => setSubject(e.target.value) })] }), _jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-body`, children: t('send.body') }), _jsx(Textarea, { id: `${id}-body`, rows: 9, maxLength: 50_000, value: body, onChange: (e) => setBody(e.target.value) })] }), c?.attachment === null || c === undefined ? null : (_jsxs("div", { className: "flex items-center gap-2 text-sm", children: [_jsx(Checkbox, { id: `${id}-attach`, checked: attach, onCheckedChange: (on) => setAttach(on === true) }), _jsxs("label", { htmlFor: `${id}-attach`, className: "flex items-center gap-1", children: [_jsx(Paperclip, { "aria-hidden": true, className: "size-4" }), c.attachment] })] })), send.error === null ? null : (_jsx("p", { role: "alert", className: "text-sm text-danger", children: send.error instanceof ApiError ? send.error.message : String(send.error) }))] }) })] }));
+}

package/dist/mail/web/SendSelected.d.ts

@@ -0,0 +1,8 @@
+/**
+ * "Send by email" in a list's bar of selected rows (RFC 0029 §3.3): each selected document goes to its partner
+ * with its own template, in the partner's language, with its PDF. Documents without an address or not ready are
+ * skipped and said so. Hidden on lists of models that are not sendable.
+ */
+import { type SelectionActionProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function SendSelected({ api, model, ids, done }: SelectionActionProps): ReactElement | null;

package/dist/mail/web/SendSelected.js

@@ -0,0 +1,33 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * "Send by email" in a list's bar of selected rows (RFC 0029 §3.3): each selected document goes to its partner
+ * with its own template, in the partner's language, with its PDF. Documents without an address or not ready are
+ * skipped and said so. Hidden on lists of models that are not sendable.
+ */
+import { ApiError, Button, Dialog } from '../../ui/index.js';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { Mail } from 'lucide-react';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+export function SendSelected({ api, model, ids, done }) {
+    const { t } = useTranslation('mail');
+    const [open, setOpen] = useState(false);
+    const sendable = useQuery({
+        queryKey: ['mail', 'sendable'],
+        queryFn: () => api.call('GET', '/api/v1/mail/sendable'),
+        staleTime: Number.POSITIVE_INFINITY,
+    });
+    const send = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/mail/send-many/${model}`, { ids }),
+        onSuccess: (r) => {
+            setOpen(false);
+            const skipped = r.skipped.length === 0
+                ? ''
+                : ` ${t('send.skipped', { count: r.skipped.length, reason: r.skipped[0]?.reason ?? '' })}`;
+            done(`${t('send.sentMany', { count: r.sent })}${skipped}`, r.sent === 0 ? 'danger' : 'info');
+        },
+    });
+    if (!(sendable.data?.models ?? []).includes(model))
+        return null;
+    return (_jsxs(_Fragment, { children: [_jsxs(Button, { size: "sm", onClick: () => setOpen(true), children: [_jsx(Mail, { "aria-hidden": true }), t('send.many')] }), _jsx(Dialog, { open: open, onOpenChange: setOpen, title: t('send.manyTitle', { count: ids.length }), description: t('send.manyIntro'), footer: _jsx(Button, { variant: "primary", busy: send.isPending, onClick: () => send.mutate(), children: t('send.confirm') }), children: send.error === null ? null : (_jsx("p", { role: "alert", className: "text-sm text-danger", children: send.error instanceof ApiError ? send.error.message : String(send.error) })) })] }));
+}

package/dist/mail/web/index.d.ts

@@ -7,6 +7,8 @@ import { type Registry } from '../../ui/index.js';
 import type { i18n } from 'i18next';
 import { messages } from './messages.js';
 export { InboundPage } from './InboundPage.js';
+export { SendButton } from './SendButton.js';
+export { SendSelected } from './SendSelected.js';
 /** Registers the page (and its messages in `i18n`, when given). */
 export declare function registerMailWeb(registry: Registry, i18n?: i18n): Registry;
 export { messages as mailMessages };

package/dist/mail/web/index.js

@@ -6,10 +6,16 @@
 import { addMessages } from '../../ui/index.js';
 import { InboundPage } from './InboundPage.js';
 import { messages } from './messages.js';
+import { SendButton } from './SendButton.js';
+import { SendSelected } from './SendSelected.js';
 export { InboundPage } from './InboundPage.js';
+export { SendButton } from './SendButton.js';
+export { SendSelected } from './SendSelected.js';
 /** Registers the page (and its messages in `i18n`, when given). */
 export function registerMailWeb(registry, i18n) {
     registry.registerPage('mail.Inbound', InboundPage);
+    registry.registerComponent('mail.Send', SendButton);
+    registry.registerSelectionAction('mail.SendSelected', SendSelected);
     if (i18n !== undefined)
         addMessages(i18n, 'mail', messages);
     return registry;

package/dist/mail/web/messages.js

@@ -1,6 +1,24 @@
 /** Messages of the inbound email page (namespace `mail`). */
 export const messages = {
     en: {
+        send: {
+            button: 'Send',
+            title: 'Send by email',
+            intro: 'The text comes from the template, in the customer’s language; change anything before sending.',
+            already: 'Sent {{count}} times already, last on {{date}}.',
+            to: 'To',
+            cc: 'Cc',
+            subject: 'Subject',
+            body: 'Message',
+            noEmail: '{{name}} has no email address: type one.',
+            confirm: 'Send',
+            queued: 'Sent: the email is on its way and on the chatter.',
+            many: 'Send by email',
+            manyTitle: 'Send {{count}} documents by email?',
+            manyIntro: 'Each goes to its customer or vendor with its own template, in their language, with its PDF; it is posted on its chatter.',
+            sentMany: '{{count}} sent by email.',
+            skipped: '{{count}} not sent: {{reason}}',
+        },
         inbound: {
             title: 'Inbound email',
             intro: 'Replies to notification emails post on their record. The messages below matched no record or no known sender: attach them to a record, or discard them.',
@@ -40,6 +58,24 @@ export const messages = {
         },
     },
     bn: {
+        send: {
+            button: 'পাঠান',
+            title: 'ইমেইলে পাঠান',
+            intro: 'লেখাটি টেমপ্লেট থেকে, গ্রাহকের ভাষায়; পাঠানোর আগে যেকোনো কিছু বদলাতে পারেন।',
+            already: 'আগে {{count}} বার পাঠানো হয়েছে, শেষবার {{date}}।',
+            to: 'প্রাপক',
+            cc: 'অনুলিপি',
+            subject: 'বিষয়',
+            body: 'বার্তা',
+            noEmail: '{{name}}-এর কোনো ইমেইল ঠিকানা নেই: একটি লিখুন।',
+            confirm: 'পাঠান',
+            queued: 'পাঠানো হয়েছে: ইমেইলটি যাচ্ছে এবং চ্যাটারে আছে।',
+            many: 'ইমেইলে পাঠান',
+            manyTitle: '{{count}}টি নথি ইমেইলে পাঠাবেন?',
+            manyIntro: 'প্রতিটি নিজ টেমপ্লেটে, প্রাপকের ভাষায়, PDF-সহ তার গ্রাহক বা সরবরাহকারীর কাছে যায়; এর চ্যাটারেও থাকে।',
+            sentMany: '{{count}}টি ইমেইলে পাঠানো হয়েছে।',
+            skipped: '{{count}}টি পাঠানো হয়নি: {{reason}}',
+        },
         inbound: {
             title: 'আগত ইমেইল',
             intro: 'বিজ্ঞপ্তি ইমেইলের উত্তর তাদের রেকর্ডে পোস্ট হয়। নিচের বার্তাগুলো কোনো রেকর্ড বা পরিচিত প্রেরকের সাথে মেলেনি: এগুলো কোনো রেকর্ডে যুক্ত করুন, অথবা বাতিল করুন।',

package/dist/maintenance/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: fa02b3043eeb7085
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: f330111b566f456e
 // Bindings of module `maintenance`: 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/maintenance/.kosh/schema.d.ts

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: fa02b3043eeb7085
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: f330111b566f456e
 // Schema view of module `maintenance` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -815,6 +815,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/maintenance/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>>;