shutro-erp 0.3.3 → 0.3.5

package/dist/event/demo.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Event Hub's demo data (RFC 0008 §5.8): a supplier day in a month — 3 seats, two ticket types and two sessions,
+ * open for registration — with two attendees confirmed, one checked in, and a third on the waiting list.
+ */
+import type { DemoContext } from '../modules-sdk/index.js';
+export declare function eventDemo(ctx: DemoContext): Promise<string>;

package/dist/event/demo.js

@@ -0,0 +1,65 @@
+const DINA = { login: 'dina', name: 'Dina Rahman', groups: ['event.manager'] };
+export async function eventDemo(ctx) {
+    await ctx.as(DINA, async (raw) => {
+        const env = raw;
+        const at = (days, hour) => {
+            const d = new Date(`${ctx.date(days)}T00:00:00`);
+            d.setHours(hour);
+            return d;
+        };
+        const [day] = (await env.model('event.event').create([
+            {
+                name: 'Supplier day 2026',
+                dateBegin: at(30, 9),
+                dateEnd: at(30, 17),
+                venue: 'Radisson Blu, Dhaka',
+                seatsMax: 3,
+                tickets: {
+                    create: [
+                        { name: 'Standard', price: '1500' },
+                        { name: 'Workshop', price: '3500', seatsMax: 1 },
+                    ],
+                },
+                sessions: {
+                    create: [
+                        {
+                            name: 'Opening and market outlook',
+                            dateBegin: at(30, 9),
+                            dateEnd: at(30, 10),
+                            room: 'Hall A',
+                        },
+                        {
+                            name: 'Workshop: e-invoicing',
+                            dateBegin: at(30, 14),
+                            dateEnd: at(30, 16),
+                            room: 'Room 2',
+                        },
+                    ],
+                },
+            },
+        ])).ids;
+        if (day === undefined)
+            return;
+        await env.model('event.event').browse([day]).publish();
+        const [standard] = (await env.model('event.ticket').search({ where: { event: day }, limit: 1 }))
+            .ids;
+        const people = [
+            { name: 'Nusrat Jahan', email: 'nusrat@example.test' },
+            { name: 'Arif Hossain', email: 'arif@example.test' },
+            { name: 'Tania Akter', email: 'tania@example.test' },
+            { name: 'Kamal Uddin', email: 'kamal@example.test' },
+        ];
+        const made = await env
+            .model('event.registration')
+            .create(people.map((p) => ({ ...p, event: day, ticket: standard ?? null })));
+        const [first, second, third, fourth] = made.ids;
+        for (const id of [first, second, third])
+            if (id !== undefined)
+                await env.model('event.registration').browse([id]).confirm();
+        if (fourth !== undefined)
+            await env.model('event.registration').browse([fourth]).wait();
+        if (first !== undefined)
+            await env.model('event.registration').browse([first]).attend();
+    });
+    return 'Event Hub: a supplier day open for registration, 3 attendees (one checked in) and one waiting.';
+}

package/dist/event/index.d.ts

@@ -0,0 +1,14 @@
+import { type Mailer } from '../mail/index.js';
+import { defineModule } from '../modules-sdk/index.js';
+export { CONFIRMED, ENDED, eventMailers } from './mails.js';
+export { EventEvent, EventRegistration, EventSession, EventTicket, eventShutro, newCode, } from './module.js';
+export interface EventOptions {
+    /** Who sends the emails; default: SMTP from the environment (`SMTP_URL`), none without it. */
+    readonly mailer?: Mailer | undefined;
+    /** Start the email workers (default: unless `KOSH_SCHEDULES=off`). */
+    readonly workers?: boolean | undefined;
+}
+/** Event Hub with explicit options (tests: a memory mailer, workers drained by hand). */
+export declare function eventModule(options?: EventOptions): ReturnType<typeof defineModule>;
+/** Event Hub: SMTP from the environment for its emails. */
+export declare const event: ReturnType<typeof defineModule>;

package/dist/event/index.js

@@ -0,0 +1,333 @@
+/**
+ * @packageDocumentation
+ * `shutro-erp/event` (RFC 0021): the **Event Hub** app. Events with sessions and ticket types, seats limited per event and
+ * per ticket, registrations confirmed while seats remain or put on a waiting list that moves up in order, and check-in
+ * by the code on the attendee's ticket.
+ *
+ * - `POST /api/v1/eventhub/checkin`   `{ code }`: the attendee checked in, once (a phone scanning the QR sends it)
+ */
+import { contacts } from '../contacts/index.js';
+import { mailerFromEnv } from '../mail/index.js';
+import { messaging } from '../messaging/index.js';
+import { defineModule } from '../modules-sdk/index.js';
+import { reporting } from '../reporting/index.js';
+import { HttpProblem } from '../server/index.js';
+import { action, calendar, form, kanban, list, search } from '../views/index.js';
+import { eventDemo } from './demo.js';
+import { CONFIRMED, ENDED, eventMailers } from './mails.js';
+import { EventEvent, EventRegistration, EventSession, EventTicket, eventShutro } from './module.js';
+export { CONFIRMED, ENDED, eventMailers } from './mails.js';
+export { EventEvent, EventRegistration, EventSession, EventTicket, eventShutro, newCode, } from './module.js';
+function registerEventRoutes({ app }) {
+    app.post('/api/v1/eventhub/checkin', async (request) => {
+        const code = String(request.body?.code ?? '')
+            .trim()
+            .toUpperCase();
+        if (code === '')
+            throw new HttpProblem(400, 'invalid-code', 'No code', 'Send the code on the ticket.');
+        return request.env(async (raw) => {
+            const env = raw;
+            const [r] = await (await env.model('event.registration').search({ where: { code }, limit: 1 })).load({ event: true, ticket: true });
+            if (r === undefined)
+                throw new HttpProblem(404, 'unknown-code', 'Unknown ticket', `No registration has the code ${code}.`);
+            if (r.state === 'attended')
+                throw new HttpProblem(409, 'already-checked-in', 'Already checked in', `${r.name} was checked in at ${r.checkedInAt?.toISOString() ?? 'an earlier time'}.`);
+            if (r.state !== 'confirmed')
+                throw new HttpProblem(409, 'not-confirmed', 'Not confirmed', `${r.name}'s registration is not confirmed.`);
+            await env.model('event.registration').browse([r.id]).attend();
+            return {
+                registration: r.id,
+                name: r.name,
+                event: r.event.name,
+                ticket: r.ticket?.name ?? null,
+            };
+        }, { write: true });
+    });
+}
+/** Event Hub with explicit options (tests: a memory mailer, workers drained by hand). */
+export function eventModule(options = {}) {
+    const mailer = 'mailer' in options ? options.mailer : mailerFromEnv();
+    return defineModule({
+        shutro: eventShutro,
+        kosh: '^0.1.0',
+        hooks: { demo: eventDemo },
+        depends: [contacts, messaging, reporting],
+        // The ticket and badge: the attendee, the event, and the QR the door scans.
+        documents: [
+            {
+                key: 'ticket',
+                name: 'Ticket and badge',
+                model: 'event.registration',
+                layout: {
+                    paper: 'A4',
+                    header: '{{company.name}}',
+                    blocks: [
+                        { kind: 'heading', id: 'event_name', text: '{{event.name}}', level: 1 },
+                        { kind: 'heading', id: 'attendee', text: '{{name}}', level: 2 },
+                        {
+                            kind: 'fields',
+                            id: 'details',
+                            items: [
+                                { label: 'Ticket', bind: 'ticket.name' },
+                                { label: 'Starts', bind: 'event.dateBegin' },
+                                { label: 'Venue', bind: 'event.venue' },
+                                { label: 'Code', bind: 'code' },
+                            ],
+                        },
+                        { kind: 'qr', id: 'qr', bind: 'code', size: 45, label: 'Show this at the door' },
+                    ],
+                },
+            },
+        ],
+        app: {
+            code: 'eventhub',
+            label: 'Event Hub',
+            icon: 'eventhub',
+            sequence: 41,
+            category: 'Marketing',
+            summary: 'Events, tickets and seats, waiting lists, check-in by QR',
+        },
+        accessLevels: {
+            user: { label: 'User (registrations, check-in)', groups: ['event.user'] },
+            manager: {
+                label: 'Manager (events, tickets, everything)',
+                groups: ['event.manager'],
+                implies: ['user'],
+            },
+        },
+        events: [
+            { topic: CONFIRMED, model: 'event.registration', label: 'Registration confirmed' },
+            { topic: ENDED, model: 'event.event', label: 'Event ended' },
+        ],
+        routes: (context) => {
+            registerEventRoutes(context);
+            if (!(options.workers ?? process.env['KOSH_SCHEDULES'] !== 'off'))
+                return;
+            const workers = eventMailers({
+                shutro: context.shutro,
+                log: (message, error) => context.app.log.error({ err: error }, message),
+            }, mailer);
+            for (const w of workers)
+                w.start();
+            context.app.addHook('onClose', async () => {
+                for (const w of workers)
+                    await w.stop();
+            });
+        },
+        // The Overview (RFC 0022 step 2).
+        overview: {
+            cards: [
+                {
+                    id: 'open_events',
+                    title: 'Open for registration',
+                    kind: 'kpi',
+                    model: 'event.event',
+                    measure: 'count',
+                    filter: { state: 'published' },
+                    w: 3,
+                },
+                {
+                    id: 'confirmed',
+                    title: 'Places confirmed',
+                    kind: 'kpi',
+                    model: 'event.registration',
+                    measure: 'count',
+                    filter: { state: { in: ['confirmed', 'attended'] } },
+                    w: 3,
+                },
+                {
+                    id: 'waiting',
+                    title: 'On waiting lists',
+                    kind: 'kpi',
+                    model: 'event.registration',
+                    measure: 'count',
+                    filter: { state: 'waiting' },
+                    w: 3,
+                },
+                {
+                    id: 'revenue',
+                    title: 'Ticket revenue',
+                    kind: 'kpi',
+                    model: 'event.registration',
+                    measure: 'sum:price',
+                    filter: { state: { in: ['confirmed', 'attended'] } },
+                    w: 3,
+                },
+                {
+                    id: 'by_event',
+                    title: 'Places by event',
+                    kind: 'pivot',
+                    model: 'event.registration',
+                    measure: 'count',
+                    groupBy: 'event',
+                    filter: { state: { in: ['confirmed', 'attended'] } },
+                    w: 6,
+                },
+                {
+                    id: 'by_ticket',
+                    title: 'By ticket type',
+                    kind: 'chart',
+                    model: 'event.registration',
+                    measure: 'count',
+                    groupBy: 'ticket',
+                    filter: { state: { in: ['confirmed', 'attended'] } },
+                    chart: 'pie',
+                    w: 6,
+                },
+                {
+                    id: 'checked_in',
+                    title: 'Checked in',
+                    kind: 'kpi',
+                    model: 'event.registration',
+                    measure: 'count',
+                    filter: { state: 'attended' },
+                    w: 3,
+                },
+                {
+                    id: 'biggest',
+                    title: 'Events by registrations',
+                    kind: 'list',
+                    model: 'event.event',
+                    measure: 'sum:seatsTaken',
+                    w: 6,
+                },
+            ],
+        },
+        actions: {
+            'eventhub.action_events': action(EventEvent, {
+                label: 'Events',
+                views: ['kanban', 'list', 'calendar', 'form'],
+            }),
+            'eventhub.action_registrations': action(EventRegistration, {
+                label: 'Registrations',
+                views: ['list', 'form'],
+            }),
+        },
+        menus: [
+            { id: 'eventhub.root', label: 'Event Hub', app: 'eventhub' },
+            {
+                id: 'eventhub.events',
+                parent: 'eventhub.root',
+                label: 'Events',
+                action: 'eventhub.action_events',
+                sequence: 1,
+            },
+            {
+                id: 'eventhub.registrations',
+                parent: 'eventhub.root',
+                label: 'Registrations',
+                action: 'eventhub.action_registrations',
+                sequence: 2,
+            },
+        ],
+        views: {
+            'event.event.kanban': kanban(EventEvent, {
+                groupBy: 'state',
+                card: { title: 'name', subtitle: 'venue', footer: ['dateBegin', 'seatsAvailable'] },
+            }),
+            'event.event.list': list(EventEvent, {
+                columns: [
+                    'name',
+                    'dateBegin',
+                    'venue',
+                    'seatsMax',
+                    'seatsTaken',
+                    'attended',
+                    { field: 'state', widget: 'badge' },
+                ],
+            }),
+            'event.event.calendar': calendar(EventEvent, {
+                dateStart: 'dateBegin',
+                dateStop: 'dateEnd',
+                title: 'name',
+                mode: 'month',
+            }),
+            'event.event.form': form(EventEvent, (k) => ({
+                header: {
+                    statusbar: 'state',
+                    buttons: [
+                        k.button('publish', { primary: true, label: 'Open registrations' }),
+                        k.button('close', { label: 'End' }),
+                        k.button('cancel', { label: 'Cancel', confirm: 'Cancel this event?' }),
+                        k.button('redraft', { label: 'Back to draft' }),
+                    ],
+                },
+                sheet: [
+                    k.group('main', ['name', 'dateBegin', 'dateEnd', 'venue', 'organizer']),
+                    k.group('seats', [
+                        'seatsMax',
+                        'seatsTaken',
+                        'seatsAvailable',
+                        'attended',
+                        'waitingList',
+                        'currency',
+                    ]),
+                    k.component('checkin', 'event.CheckIn'),
+                    k.lines('tickets', [
+                        { field: 'name', id: 'ticket_name' },
+                        { field: 'price', id: 'ticket_price' },
+                        { field: 'seatsMax', id: 'ticket_seats' },
+                        { field: 'saleEnd', id: 'ticket_sale_end' },
+                        { field: 'seatsTaken', id: 'ticket_sold' },
+                    ]),
+                    k.lines('sessions', [
+                        { field: 'name', id: 'session_name' },
+                        { field: 'dateBegin', id: 'session_begin' },
+                        { field: 'dateEnd', id: 'session_end' },
+                        { field: 'room', id: 'session_room' },
+                        { field: 'speaker', id: 'session_speaker' },
+                    ]),
+                    k.group('about', ['description'], { columns: 1 }),
+                ],
+                chatter: true,
+            })),
+            'event.registration.list': list(EventRegistration, {
+                columns: ['name', 'event', 'ticket', 'email', 'code', { field: 'state', widget: 'badge' }],
+            }),
+            'event.registration.form': form(EventRegistration, (k) => ({
+                header: {
+                    statusbar: 'state',
+                    buttons: [
+                        k.button('confirm', { primary: true, label: 'Confirm' }),
+                        k.button('wait', { label: 'Waiting list' }),
+                        k.button('attend', { primary: true, label: 'Check in' }),
+                        k.button('cancel', { label: 'Cancel' }),
+                    ],
+                },
+                sheet: [
+                    k.group('main', ['event', 'ticket', 'name', 'email', 'phone', 'partner', 'lang']),
+                    k.group('ticket_info', ['code', 'price', 'checkedInAt']),
+                ],
+                chatter: true,
+            })),
+            'event.ticket.list': list(EventTicket, {
+                columns: ['event', 'name', 'price', 'seatsMax', 'seatsTaken'],
+            }),
+            'event.session.list': list(EventSession, {
+                columns: ['event', 'name', 'dateBegin', 'dateEnd', 'room', 'speaker'],
+            }),
+        },
+        search: {
+            'event.event': search(EventEvent, {
+                fields: ['name', 'venue'],
+                filters: {
+                    open: { label: 'Open for registration', domain: { state: 'published' } },
+                },
+                groupBy: ['state', 'organizer'],
+            }),
+            'event.registration': search(EventRegistration, {
+                fields: ['name', 'email', 'code', 'event.name'],
+                filters: {
+                    confirmed: { label: 'Confirmed', domain: { state: 'confirmed' }, group: 'state' },
+                    waiting: { label: 'Waiting list', domain: { state: 'waiting' }, group: 'state' },
+                    attended: { label: 'Checked in', domain: { state: 'attended' }, group: 'state' },
+                },
+                groupBy: ['event', 'ticket', 'state'],
+            }),
+            'event.ticket': search(EventTicket, { fields: ['name', 'event.name'] }),
+            'event.session': search(EventSession, { fields: ['name', 'speaker', 'event.name'] }),
+        },
+    });
+}
+/** Event Hub: SMTP from the environment for its emails. */
+export const event = eventModule();

package/dist/event/mails.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Event Hub's emails (RFC 0021, Event Hub step 3): the confirmation to an attendee whose place is confirmed (also
+ * when the waiting list moves them up), with their ticket and check-in code, and the thanks to those who came, once
+ * the event ends. Through the outbox — each sent once (its time is kept on the registration), after the commit; a
+ * failed send is logged. In the attendee's language (English or Bangla, on the registration).
+ */
+import { type Mailer } from '../mail/index.js';
+import type { ModuleContext } from '../server/index.js';
+import type { Worker } from '../server/orm.js';
+export declare const CONFIRMED = "event.registration.confirmed";
+export declare const ENDED = "event.event.ended";
+/** The workers that send Event Hub's emails; `start()` them (the module does), tests `drain()` them. */
+export declare function eventMailers(context: Pick<ModuleContext, 'shutro'> & {
+    readonly log?: (message: string, error: unknown) => void;
+}, mailer: Mailer | undefined): Worker[];

package/dist/event/mails.js

@@ -0,0 +1,112 @@
+/**
+ * Event Hub's emails (RFC 0021, Event Hub step 3): the confirmation to an attendee whose place is confirmed (also
+ * when the waiting list moves them up), with their ticket and check-in code, and the thanks to those who came, once
+ * the event ends. Through the outbox — each sent once (its time is kept on the registration), after the commit; a
+ * failed send is logged. In the attendee's language (English or Bangla, on the registration).
+ */
+import { layout } from '../mail/index.js';
+export const CONFIRMED = 'event.registration.confirmed';
+export const ENDED = 'event.event.ended';
+const TEXTS = {
+    en: {
+        confirmedSubject: (event) => `Your place at ${event} is confirmed`,
+        confirmed: (name, event, when, venue) => `${name}, your registration for ${event} on ${when}${venue === '' ? '' : ` at ${venue}`} is confirmed.`,
+        ticket: (ticket) => `Ticket: ${ticket}.`,
+        code: (code) => `Your check-in code is ${code}: show it, or your printed ticket, at the door.`,
+        thanksSubject: (event) => `Thank you for coming to ${event}`,
+        thanks: (name, event) => `${name}, thank you for coming to ${event}. We hope to see you at the next one.`,
+    },
+    bn: {
+        confirmedSubject: (event) => `${event}-এ আপনার আসন নিশ্চিত হয়েছে`,
+        confirmed: (name, event, when, venue) => `${name}, ${when}${venue === '' ? '' : `, ${venue}`}-এ ${event}-এর জন্য আপনার নিবন্ধন নিশ্চিত হয়েছে।`,
+        ticket: (ticket) => `টিকিট: ${ticket}।`,
+        code: (code) => `আপনার চেক-ইন কোড ${code}: দরজায় এটি বা আপনার ছাপানো টিকিট দেখান।`,
+        thanksSubject: (event) => `${event}-এ আসার জন্য ধন্যবাদ`,
+        thanks: (name, event) => `${name}, ${event}-এ আসার জন্য ধন্যবাদ। পরের আয়োজনে আবার দেখা হবে আশা করি।`,
+    },
+};
+/** The workers that send Event Hub's emails; `start()` them (the module does), tests `drain()` them. */
+export function eventMailers(context, mailer) {
+    const send = (env, mails) => {
+        if (mailer === undefined || mails.length === 0)
+            return;
+        env.afterCommit(async () => {
+            for (const mail of mails)
+                await mailer
+                    .send(mail)
+                    .catch((error) => context.log?.('event email not sent', error));
+        });
+    };
+    const textsOf = (lang) => (String(lang ?? '').startsWith('bn') ? TEXTS.bn : TEXTS.en);
+    return [
+        context.shutro.subscribe('event.confirmations', CONFIRMED, async (event, raw) => {
+            const env = raw;
+            const id = Number(event.payload?.id);
+            if (!Number.isInteger(id))
+                return;
+            await env.asSuperuser({ reason: 'event confirmation email' }, async (su) => {
+                const [r] = await su
+                    .model('event.registration')
+                    .browse([id])
+                    .load({ event: true, ticket: true, partner: true });
+                if (r === undefined || r.state !== 'confirmed' || r.confirmationSentAt !== null)
+                    return;
+                const to = r.email ?? r.partner?.email ?? null;
+                await su
+                    .model('event.registration')
+                    .browse([r.id])
+                    .write({ confirmationSentAt: new Date() });
+                if (to === null || to === '')
+                    return;
+                const t = textsOf(r.lang);
+                const when = r.event.dateBegin.toISOString().slice(0, 16).replace('T', ' ');
+                const subject = t.confirmedSubject(r.event.name);
+                send(su, [
+                    {
+                        to,
+                        subject,
+                        ...layout({
+                            title: subject,
+                            paragraphs: [
+                                t.confirmed(r.name, r.event.name, when, r.event.venue ?? ''),
+                                ...(r.ticket === null ? [] : [t.ticket(r.ticket.name)]),
+                                t.code(r.code),
+                            ],
+                            lang: String(r.lang ?? 'en').slice(0, 2),
+                        }),
+                    },
+                ]);
+            });
+        }, { pollMs: 5000 }),
+        context.shutro.subscribe('event.thanks', ENDED, async (event, raw) => {
+            const env = raw;
+            const id = Number(event.payload?.id);
+            if (!Number.isInteger(id))
+                return;
+            await env.asSuperuser({ reason: 'event thanks email' }, async (su) => {
+                const came = await (await su.model('event.registration').search({
+                    where: { event: id, state: 'attended', thanksSentAt: { isNull: true } },
+                })).load({ event: true, partner: true });
+                const mails = [];
+                for (const r of came) {
+                    await su.model('event.registration').browse([r.id]).write({ thanksSentAt: new Date() });
+                    const to = r.email ?? r.partner?.email ?? null;
+                    if (to === null || to === '')
+                        continue;
+                    const t = textsOf(r.lang);
+                    const subject = t.thanksSubject(r.event.name);
+                    mails.push({
+                        to,
+                        subject,
+                        ...layout({
+                            title: subject,
+                            paragraphs: [t.thanks(r.name, r.event.name)],
+                            lang: String(r.lang ?? 'en').slice(0, 2),
+                        }),
+                    });
+                }
+                send(su, mails);
+            });
+        }, { pollMs: 5000 }),
+    ];
+}