shutro-erp 0.3.6 → 0.3.7

package/dist/l10n_in/module.js

@@ -262,7 +262,10 @@ export const GstEinvoice = defineModel('l10n_in.einvoice', {
     fields: {
         move: f.many2one('account.move', { required: true, ondelete: 'cascade' }),
         /** E-invoicing (RFC 0016 step 5, part 4): the IRP's answer, written only by the registration. */
-        einvoiceStatus: f.selection(EINVOICE_STATES, { label: 'E-invoice' }),
+        einvoiceStatus: f.selection(EINVOICE_STATES, {
+            label: 'E-invoice',
+            help: 'Whether the invoice was registered at the Invoice Registration Portal and got its IRN, failed, or was cancelled there.',
+        }),
         irn: f.char({ size: 64, label: 'IRN' }),
         irnAckNo: f.char({ size: 20, label: 'Acknowledgement number' }),
         irnAckDate: f.datetime({ label: 'Acknowledged at' }),
@@ -274,9 +277,15 @@ export const GstEinvoice = defineModel('l10n_in.einvoice', {
         ewbNo: f.char({ size: 12, label: 'E-way bill' }),
         ewbDate: f.datetime({ label: 'E-way bill generated at' }),
         ewbValidUntil: f.datetime({ label: 'E-way bill valid until' }),
-        ewbStatus: f.selection({ generated: 'Generated', failed: 'Not generated: see the error', cancelled: 'Cancelled' }, { label: 'E-way bill status' }),
+        ewbStatus: f.selection({ generated: 'Generated', failed: 'Not generated: see the error', cancelled: 'Cancelled' }, {
+            label: 'E-way bill status',
+            help: 'Whether the e-way bill for moving the goods was generated, failed or was cancelled.',
+        }),
         ewbError: f.text({ label: 'E-way bill error' }),
-        ewbMode: f.selection({ road: 'Road', rail: 'Rail', air: 'Air', ship: 'Ship' }, { label: 'Transport mode' }),
+        ewbMode: f.selection({ road: 'Road', rail: 'Rail', air: 'Air', ship: 'Ship' }, {
+            label: 'Transport mode',
+            help: 'How the goods travel under the e-way bill: by road, rail, air or ship.',
+        }),
         ewbVehicleNo: f.char({ size: 15, label: 'Vehicle number' }),
         ewbTransporterId: f.char({ size: 15, label: 'Transporter ID' }),
         ewbDistanceKm: f.integer({ label: 'Distance (km)' }),
@@ -332,6 +341,7 @@ export const MoveGst = extendModel('account.move', {
         /** E-invoicing (RFC 0016 step 5, part 4): the IRP's answer (its record's). */
         einvoiceStatus: f.selection(EINVOICE_STATES, {
             label: 'E-invoice',
+            help: 'Whether the invoice was registered at the Invoice Registration Portal and got its IRN, failed, or was cancelled there.',
             store: true,
             ...fromEinvoice,
         }),
@@ -346,9 +356,19 @@ export const MoveGst = extendModel('account.move', {
         ewbNo: f.char({ size: 12, label: 'E-way bill', store: true, ...fromEinvoice }),
         ewbDate: f.datetime({ label: 'E-way bill generated at', store: true, ...fromEinvoice }),
         ewbValidUntil: f.datetime({ label: 'E-way bill valid until', store: true, ...fromEinvoice }),
-        ewbStatus: f.selection({ generated: 'Generated', failed: 'Not generated: see the error', cancelled: 'Cancelled' }, { label: 'E-way bill status', store: true, ...fromEinvoice }),
+        ewbStatus: f.selection({ generated: 'Generated', failed: 'Not generated: see the error', cancelled: 'Cancelled' }, {
+            label: 'E-way bill status',
+            help: 'Whether the e-way bill for moving the goods was generated, failed or was cancelled.',
+            store: true,
+            ...fromEinvoice,
+        }),
         ewbError: f.text({ label: 'E-way bill error', store: true, ...fromEinvoice }),
-        ewbMode: f.selection({ road: 'Road', rail: 'Rail', air: 'Air', ship: 'Ship' }, { label: 'Transport mode', store: true, ...fromEinvoice }),
+        ewbMode: f.selection({ road: 'Road', rail: 'Rail', air: 'Air', ship: 'Ship' }, {
+            label: 'Transport mode',
+            help: 'How the goods travel under the e-way bill: by road, rail, air or ship.',
+            store: true,
+            ...fromEinvoice,
+        }),
         ewbVehicleNo: f.char({ size: 15, label: 'Vehicle number', store: true, ...fromEinvoice }),
         ewbTransporterId: f.char({ size: 15, label: 'Transporter ID', store: true, ...fromEinvoice }),
         ewbDistanceKm: f.integer({ label: 'Distance (km)', store: true, ...fromEinvoice }),

package/dist/l10n_in/web/GstSettings.js

@@ -1,4 +1,4 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
  * The company's GST settings (RFC 0016 step 5, part 4), on the GST returns page: GSTIN, PAN, the address and PIN code
  * the IRP needs, and e-invoicing on or off. Managers change them; the server checks the GSTIN against the company's
@@ -27,7 +27,7 @@ export function GstSettings({ api }) {
     });
     const current = settings.data;
     if (current === undefined)
-        return _jsx(_Fragment, {});
+        return _jsx("div", {});
     const value = (key) => String(edits[key] ?? current[key] ?? '');
     const einvoice = Boolean(edits.einvoiceEnabled ?? current.einvoiceEnabled);
     return (_jsxs("section", { className: "grid max-w-3xl gap-3 rounded-lg border p-4", "aria-labelledby": `${id}-title`, children: [_jsx("h2", { id: `${id}-title`, className: "font-medium", children: t('settings.title') }), _jsx("p", { className: "text-sm text-muted-foreground", children: current.provider === null

package/dist/mail/inbound/handle.js

@@ -236,9 +236,7 @@ export async function processInbound(context, logId, mail) {
             message: null,
         });
     const recipientEmail = await context.shutro.bootstrap({ reason: 'inbound email' }, async (su) => {
-        const [user] = await rows(su, 'res.users', { id: target.uid, active: { in: [true, false] } }, [
-            'email',
-        ]);
+        const [user] = await rows(su.withFlags({ activeTest: false }), 'res.users', { id: target.uid }, ['email']);
         return typeof user?.['email'] === 'string' ? user['email'].toLowerCase() : '';
     });
     if (sender !== '' && sender === recipientEmail) {
@@ -377,7 +375,7 @@ async function recordBounce(context, mail) {
             ]);
             if (n === undefined || typeof n['actor'] !== 'number' || n['actor'] === n['user'])
                 continue;
-            const [recipient] = await rows(su, 'res.users', { id: n['user'], active: { in: [true, false] } }, ['name', 'email']);
+            const [recipient] = await rows(su.withFlags({ activeTest: false }), 'res.users', { id: n['user'] }, ['name', 'email']);
             const [record] = (await ref(su, String(n['resModel']))
                 .browse([n['resId']])
                 .load(['displayName'])).read(['displayName']);

package/dist/mail/inbound/models.js

@@ -6,6 +6,8 @@
  */
 import { messagingShutro } from '../../messaging/index.js';
 import { orm } from '../../server/orm.js';
+import { storageShutro } from '../../storage/index.js';
+import { SEND_MODELS } from '../send.js';
 const { defineGroup, defineModel, defineModule, f } = orm;
 export const INBOUND_STATES = [
     'received',
@@ -53,8 +55,8 @@ const InboundMessage = defineModel('mail.inbound_message', {
 });
 export const mailShutro = defineModule({
     name: 'mail',
-    version: '0.1.0',
-    depends: [messagingShutro],
+    version: '0.2.0',
+    depends: [messagingShutro, storageShutro],
     groups: [
         defineGroup({
             code: 'mail.manager',
@@ -62,5 +64,5 @@ export const mailShutro = defineModule({
             implies: ['base.user', 'messaging.user'],
         }),
     ],
-    models: [InboundMessage],
+    models: [InboundMessage, ...SEND_MODELS],
 });

package/dist/mail/index.d.ts

@@ -1,5 +1,6 @@
 import { defineModule } from '../modules-sdk/index.js';
 import { type ImapConfig } from './inbound/index.js';
+export { type BatchResult, type Composition, installMailTemplates, type SendEngine, sendablesOf, } from './send.js';
 import { type InboundConfig } from './inbound/token.js';
 export * from './inbound/index.js';
 /** One outbound message. */
@@ -10,6 +11,14 @@ export interface OutboundMail {
     readonly text: string;
     readonly html: string;
     readonly replyTo?: string;
+    /** Copies (RFC 0029 §3.3). */
+    readonly cc?: readonly string[];
+    /** Files sent with it: a document's PDF. */
+    readonly attachments?: readonly {
+        readonly filename: string;
+        readonly content: Uint8Array;
+        readonly contentType: string;
+    }[];
 }
 /** Sends messages; the provider's id of each, when it gives one. */
 export interface Mailer {
@@ -68,8 +77,10 @@ export interface MailOptions {
     readonly webhookSecret?: string | undefined;
     /** The mailbox to poll; default `IMAP_URL`. Without one, no poller runs. */
     readonly imap?: ImapConfig | undefined;
-    /** Start the poller (default: unless `KOSH_SCHEDULES=off`). */
+    /** Start the poller and the sender (default: unless `KOSH_SCHEDULES=off`). */
     readonly workers?: boolean | undefined;
+    /** The mailer documents are sent with (RFC 0029 §3.3); default: `SMTP_URL`. `null`: none. */
+    readonly mailer?: Mailer | null | undefined;
 }
 /** The mail module with explicit settings. */
 export declare function mailModule(options?: MailOptions): ReturnType<typeof defineModule>;

package/dist/mail/index.js

@@ -9,11 +9,14 @@
  */
 import { chatterContext, messaging } from '../messaging/index.js';
 import { defineModule } from '../modules-sdk/index.js';
-import { base } from '../server/index.js';
+import { base, HttpProblem } from '../server/index.js';
 import { storage, storageOf } from '../storage/index.js';
+import { form, list } from '../views/index.js';
 import nodemailer from 'nodemailer';
 import { imapConfigFromEnv, registerInboundRoutes, startPoller, } from './inbound/index.js';
 import { mailShutro } from './inbound/models.js';
+import { installMailTemplates, sendEngine } from './send.js';
+export { installMailTemplates, sendablesOf, } from './send.js';
 import { inboundConfigFromEnv } from './inbound/token.js';
 export * from './inbound/index.js';
 /** The SMTP mailer: `url` is `smtp://user:pass@host:port` (or `smtps://` for implicit TLS). */
@@ -30,6 +33,16 @@ export function createSmtpMailer(options) {
                 text: mail.text,
                 html: mail.html,
                 ...(mail.replyTo === undefined ? {} : { replyTo: mail.replyTo }),
+                ...(mail.cc === undefined || mail.cc.length === 0 ? {} : { cc: [...mail.cc] }),
+                ...(mail.attachments === undefined
+                    ? {}
+                    : {
+                        attachments: mail.attachments.map((a) => ({
+                            filename: a.filename,
+                            content: Buffer.from(a.content),
+                            contentType: a.contentType,
+                        })),
+                    }),
             });
             return { id: typeof info.messageId === 'string' ? info.messageId : null };
         },
@@ -126,19 +139,79 @@ export function mailModule(options = {}) {
             icon: 'mail',
             sequence: 950,
             category: 'Administration',
-            summary: 'Inbound email: replies posted on records, and the ones that matched no one',
+            summary: 'Documents sent with their PDF, email templates, and replies posted on records or quarantined',
         },
         accessLevels: {
             manager: { label: 'Email manager (the inbound log)', groups: ['mail.manager'] },
         },
         actions: {
             'mail.action_inbound': { type: 'client', page: 'mail.Inbound', label: 'Inbound email' },
+            'mail.action_templates': {
+                model: 'mail.template',
+                label: 'Email templates',
+                views: ['list', 'form'],
+            },
+            'mail.action_outgoing': { model: 'mail.outgoing', label: 'Sent', views: ['list', 'form'] },
         },
         menus: [
             { id: 'mail.root', label: 'Email', app: 'mail' },
             { id: 'mail.inbound', parent: 'mail.root', label: 'Inbound', action: 'mail.action_inbound' },
+            {
+                id: 'mail.outgoing',
+                parent: 'mail.root',
+                label: 'Sent',
+                action: 'mail.action_outgoing',
+                sequence: 2,
+            },
+            {
+                id: 'mail.templates',
+                parent: 'mail.root',
+                label: 'Email templates',
+                action: 'mail.action_templates',
+                sequence: 3,
+            },
         ],
+        views: {
+            'mail.template.list': list('mail.template', {
+                columns: ['name', 'targetModel', 'subject', 'document'],
+            }),
+            'mail.template.form': form('mail.template', (k) => ({
+                header: { buttons: [] },
+                sheet: [
+                    k.group('main', ['name', 'targetModel', 'subject', 'body', 'document'], {
+                        columns: 1,
+                        description: 'Placeholders like {{name}} or {{partner.name}} are filled from the document; each language keeps its own text.',
+                    }),
+                ],
+            })),
+            'mail.outgoing.list': list('mail.outgoing', {
+                columns: ['createdAt', 'to', 'subject', 'resModel', 'author', 'state'],
+            }),
+            'mail.outgoing.form': form('mail.outgoing', (k) => ({
+                header: { buttons: [], statusbar: 'state' },
+                sheet: [
+                    k.group('main', ['to', 'cc', 'subject', 'resModel', 'resId', 'author', 'sentAt']),
+                    k.group('content', ['text', 'attachments', 'error', 'providerId'], { columns: 1 }),
+                ],
+            })),
+        },
+        search: {
+            'mail.template': {
+                fields: ['name', 'targetModel', 'subject'],
+            },
+            'mail.outgoing': {
+                fields: ['to', 'subject'],
+                filters: {
+                    failed: { label: 'Failed', domain: { state: 'failed' }, group: 'state' },
+                    queued: { label: 'Queued', domain: { state: 'queued' }, group: 'state' },
+                },
+                groupBy: ['state', 'resModel'],
+            },
+        },
         privateModels: ['mail.inbound_message'],
+        hooks: {
+            defaults: async (env, modules) => `${await installMailTemplates(env, modules)} email template(s) installed`,
+        },
         routes: (context) => {
             const inbound = {
                 shutro: context.shutro,
@@ -152,9 +225,73 @@ export function mailModule(options = {}) {
             registerInboundRoutes(context, inbound, {
                 webhookSecret: options.webhookSecret ?? process.env['MAIL_INBOUND_WEBHOOK_SECRET'],
             });
+            // Sending documents (RFC 0029 §3.3).
+            const outbound = options.mailer === undefined ? mailerFromEnv() : (options.mailer ?? undefined);
+            const engine = sendEngine(context, () => outbound);
+            const target = (params) => {
+                const p = params;
+                const id = Number(p.id);
+                if (typeof p.model !== 'string' || !Number.isSafeInteger(id) || id <= 0)
+                    throw new HttpProblem(400, 'invalid-path', 'Invalid record', 'A model and a record id.');
+                return { model: p.model, id };
+            };
+            context.app.get('/api/v1/mail/sendable', async () => ({
+                models: [...engine.sendables.keys()],
+                mailer: outbound !== undefined,
+            }));
+            context.app.get('/api/v1/mail/compose/:model/:id', async (request) => {
+                const { model, id } = target(request.params);
+                return request.env((env) => engine.compose(env, model, id));
+            });
+            context.app.post('/api/v1/mail/send/:model/:id', async (request) => {
+                const { model, id } = target(request.params);
+                return request.env((env) => engine.send(env, model, id, (request.body ?? {})), { write: true });
+            });
+            context.app.post('/api/v1/mail/send-many/:model', async (request) => {
+                const model = request.params.model;
+                const ids = request.body?.ids;
+                if (typeof model !== 'string' ||
+                    !Array.isArray(ids) ||
+                    !ids.every((i) => Number.isSafeInteger(i) && i > 0))
+                    throw new HttpProblem(400, 'invalid-body', 'Invalid batch', '{ ids: [record ids] }.');
+                return request.env((env) => engine.sendMany(env, model, ids), {
+                    write: true,
+                });
+            });
             // Background work is off in the CLI (kosh init, migrate), like the schedules.
             if (!(options.workers ?? process.env['KOSH_SCHEDULES'] !== 'off'))
                 return;
+            // Documents sent by themselves (`autoSend`): as the user whose change emitted the event.
+            for (const [model, spec] of engine.sendables) {
+                if (spec.autoSend === undefined)
+                    continue;
+                const worker = context.shutro.subscribe(`mail.auto.${model}`, spec.autoSend.topic, async (event, env) => {
+                    const id = Number(event.payload?.id);
+                    if (!Number.isSafeInteger(id))
+                        return;
+                    try {
+                        await engine.autoSend(env, model, id);
+                    }
+                    catch (error) {
+                        // A document that cannot be sent (no template, no storage) is logged, never retried forever.
+                        context.app.log.warn({ err: error, model, id }, 'automatic email not sent');
+                    }
+                }, { pollMs: 2000 });
+                worker.start();
+                context.app.addHook('onClose', async () => {
+                    await worker.stop();
+                });
+            }
+            const sender = context.shutro.subscribe('mail.send', 'mail.outgoing.queued', async (event, env) => {
+                const id = Number(event.payload?.outgoing);
+                if (!Number.isSafeInteger(id))
+                    return;
+                await env.asSuperuser({ reason: 'email sent from a record' }, (su) => engine.deliver(su, id));
+            }, { pollMs: 2000 });
+            sender.start();
+            context.app.addHook('onClose', async () => {
+                await sender.stop();
+            });
             const imap = options.imap ?? imapConfigFromEnv();
             if (imap === undefined)
                 return;

package/dist/mail/send.d.ts

@@ -0,0 +1,56 @@
+import type { KoshModule, SendableSpec } from '../modules-sdk/index.js';
+import { type ModuleContext } from '../server/index.js';
+import { type Env } from '../server/orm.js';
+import { type Mailer } from './index.js';
+/** The models of sending documents, added to the mail module's. */
+export declare const SEND_MODELS: readonly unknown[];
+/** The sendable documents of the loaded modules, by model. */
+export declare function sendablesOf(modules: readonly KoshModule[]): Map<string, SendableSpec>;
+/** Installs the manifests' email templates that do not exist yet (by `module.key`). */
+export declare function installMailTemplates(env: Env, modules: readonly KoshModule[]): Promise<number>;
+/** What the Send dialog shows, filled in the partner's language. */
+export interface Composition {
+    readonly to: readonly {
+        readonly name: string;
+        readonly email: string | null;
+    }[];
+    readonly subject: string;
+    readonly body: string;
+    /** The PDF that goes with it, or none. */
+    readonly attachment: string | null;
+    readonly lang: string;
+    /** Emails sent from this record so far, and the last one's date. */
+    readonly sent: number;
+    readonly lastSentAt: string | null;
+}
+/** The send engine of one server. */
+export interface SendEngine {
+    readonly sendables: ReadonlyMap<string, SendableSpec>;
+    compose(env: Env, model: string, id: number): Promise<Composition>;
+    send(env: Env, model: string, id: number, input: {
+        to?: unknown;
+        cc?: unknown;
+        subject?: unknown;
+        body?: unknown;
+        attach?: unknown;
+    }): Promise<{
+        outgoing: number;
+        message: number;
+        attachment: number | null;
+    }>;
+    deliver(su: Env, outgoing: number): Promise<void>;
+    /** Sends each record as its template says, to its partner; the ones that cannot be sent are said why. */
+    sendMany(env: Env, model: string, ids: readonly number[]): Promise<BatchResult>;
+    /** Sends a record by itself (an `autoSend` event) when its partner asked for it; whether it was sent. */
+    autoSend(env: Env, model: string, id: number): Promise<boolean>;
+}
+/** What a batch send did. */
+export interface BatchResult {
+    readonly sent: number;
+    readonly skipped: readonly {
+        readonly id: number;
+        readonly reason: string;
+    }[];
+}
+/** The send engine of one server: the sendable documents, the models' metadata, the mailer. */
+export declare function sendEngine(context: ModuleContext, mailer: () => Mailer | undefined): SendEngine;