shutro-erp 0.3.4 → 0.3.6

package/dist/event/module.js

@@ -0,0 +1,323 @@
+/**
+ * The data layer of Event Hub (RFC 0021): events with their sessions and ticket types, seats limited per event and
+ * per ticket, registrations confirmed while seats remain — else on a waiting list, promoted in order when a seat
+ * frees — and checked in once by their code (the QR on the ticket).
+ */
+import { randomBytes } from 'node:crypto';
+import { contactsShutro } from '../contacts/index.js';
+import { messagingShutro } from '../messaging/index.js';
+import { orm } from '../server/orm.js';
+import { check, compute, defineModel, defineModule, f, method, records, } from './.kosh/bindings.js';
+const ALL = ['read', 'write', 'create', 'unlink'];
+const HOLDS = ['confirmed', 'attended'];
+/** A registration's code: what its QR carries (unguessable, short enough to type). */
+export const newCode = () => randomBytes(6).toString('hex').toUpperCase();
+export const EventEvent = defineModel('event.event', {
+    label: 'Event',
+    recName: 'name',
+    order: ['dateBegin desc', 'id desc'],
+    companyScoped: { required: true },
+    tracking: ['state', 'dateBegin', 'seatsMax'],
+    access: {
+        'event.user': ['read', 'write', 'create'],
+        'event.manager': [...ALL, 'export', 'import'],
+    },
+    fields: {
+        name: f.char({ required: true }),
+        dateBegin: f.datetime({ required: true, label: 'Starts' }),
+        dateEnd: f.datetime({ required: true, label: 'Ends' }),
+        venue: f.char(),
+        organizer: f.many2one('res.users', {
+            default: (env) => env.userId,
+            ondelete: 'set null',
+            label: 'Organiser',
+        }),
+        /** 0: no limit. */
+        seatsMax: f.integer({ required: true, default: 0, label: 'Seats (0: no limit)' }),
+        waitingList: f.boolean({ default: true, label: 'Waiting list when full' }),
+        currency: f.many2one('res.currency', { ondelete: 'restrict' }),
+        tickets: f.one2many('event.ticket', 'event', { label: 'Tickets' }),
+        sessions: f.one2many('event.session', 'event'),
+        registrations: f.one2many('event.registration', 'event'),
+        seatsTaken: f.integer({
+            store: true,
+            label: 'Seats taken',
+            ...compute('event.event', 'seatsTaken', ['registrations.state'], (events) => {
+                for (const e of events)
+                    e.seatsTaken = [...e.registrations].filter((r) => HOLDS.includes(r.state)).length;
+            }),
+        }),
+        seatsAvailable: f.integer({
+            store: true,
+            label: 'Seats left',
+            ...compute('event.event', 'seatsAvailable', ['seatsMax', 'seatsTaken'], (events) => {
+                for (const e of events)
+                    e.seatsAvailable = e.seatsMax > 0 ? Math.max(0, e.seatsMax - (e.seatsTaken ?? 0)) : null;
+            }),
+        }),
+        attended: f.integer({
+            store: true,
+            label: 'Checked in',
+            ...compute('event.event', 'attended', ['registrations.state'], (events) => {
+                for (const e of events)
+                    e.attended = [...e.registrations].filter((r) => r.state === 'attended').length;
+            }),
+        }),
+        description: f.text(),
+        state: f.state({
+            states: {
+                draft: 'Draft',
+                published: 'Open for registration',
+                done: 'Ended',
+                cancel: 'Cancelled',
+            },
+            initial: 'draft',
+            transitions: {
+                publish: { from: ['draft'], to: 'published' },
+                close: {
+                    from: ['published'],
+                    to: 'done',
+                    // Those who came are thanked (the outbox: Event Hub's emails).
+                    after: records('event.event', async (events) => {
+                        for (const id of events.ids)
+                            await events.env.emit('event.event.ended', { id });
+                    }),
+                },
+                cancel: { from: ['draft', 'published'], to: 'cancel' },
+                redraft: { from: ['cancel'], to: 'draft' },
+            },
+        }),
+    },
+    sqlConstraints: {
+        seats: { check: orm.sql `seats_max >= 0`, message: 'Seats are a number, 0 for no limit.' },
+        dates: { check: orm.sql `date_end >= date_begin`, message: 'An event ends after it starts.' },
+    },
+});
+export const EventTicket = defineModel('event.ticket', {
+    label: 'Ticket type',
+    recName: 'name',
+    order: ['id asc'],
+    access: { 'event.user': ['read'], 'event.manager': ALL },
+    fields: {
+        event: f.many2one('event.event', { required: true, ondelete: 'cascade' }),
+        name: f.char({ required: true }),
+        price: f.decimal({ scale: 2, required: true, default: '0' }),
+        /** 0: no limit of its own. */
+        seatsMax: f.integer({ required: true, default: 0, label: 'Seats (0: no limit)' }),
+        /** The last day it is sold (empty: until the event). */
+        saleEnd: f.date({ label: 'Sold until' }),
+        registrations: f.one2many('event.registration', 'ticket'),
+        seatsTaken: f.integer({
+            store: true,
+            label: 'Sold',
+            ...compute('event.ticket', 'seatsTaken', ['registrations.state'], (tickets) => {
+                for (const t of tickets)
+                    t.seatsTaken = [...t.registrations].filter((r) => HOLDS.includes(r.state)).length;
+            }),
+        }),
+    },
+    sqlConstraints: {
+        sensible: {
+            check: orm.sql `price >= 0 AND seats_max >= 0`,
+            message: 'A ticket has a price and seats that are not negative.',
+        },
+    },
+});
+export const EventSession = defineModel('event.session', {
+    label: 'Session',
+    recName: 'name',
+    order: ['dateBegin asc', 'id asc'],
+    access: { 'event.user': ['read'], 'event.manager': ALL },
+    fields: {
+        event: f.many2one('event.event', { required: true, ondelete: 'cascade' }),
+        name: f.char({ required: true }),
+        dateBegin: f.datetime({ required: true, label: 'Starts' }),
+        dateEnd: f.datetime({ required: true, label: 'Ends' }),
+        room: f.char(),
+        speaker: f.char(),
+    },
+    constraints: {
+        // A session happens during its event, and ends after it starts.
+        withinTheEvent: {
+            ...check('event.session', ['dateBegin', 'dateEnd', 'event'], async (sessions) => (await sessions.load({ event: true }))
+                .filter((s) => s.dateEnd < s.dateBegin ||
+                s.dateBegin < s.event.dateBegin ||
+                s.dateEnd > s.event.dateEnd)
+                .map((s) => s.id)),
+            message: 'A session happens during its event.',
+        },
+    },
+});
+/** Whether `registration` would find a seat (its event's and its ticket's), not counting itself. */
+async function seatFor(env, registration) {
+    return env.asSuperuser({ reason: 'event seats' }, async (su) => {
+        const [event] = await su.model('event.event').browse([registration.event]).load({});
+        if (event === undefined)
+            return false;
+        const holding = async (where) => (await su.model('event.registration').search({
+            where: { ...where, state: { in: [...HOLDS] }, id: { ne: registration.id } },
+        })).length;
+        if (event.seatsMax > 0 && (await holding({ event: registration.event })) >= event.seatsMax)
+            return false;
+        if (registration.ticket !== null) {
+            const [ticket] = await su.model('event.ticket').browse([registration.ticket]).load({});
+            if (ticket !== undefined &&
+                ticket.seatsMax > 0 &&
+                (await holding({ ticket: registration.ticket })) >= ticket.seatsMax)
+                return false;
+        }
+        return true;
+    });
+}
+/** What follows a confirmed place: other apps' hook, and the confirmation email (through the outbox). */
+async function placeConfirmed(env, ids) {
+    await env.model('event.registration').browse(ids).confirmed();
+    for (const id of ids)
+        await env.emit('event.registration.confirmed', { id });
+}
+/** Promotes the first waiting registrations of these events while seats are free (in the order they came). */
+async function promoteWaiting(env, events) {
+    await env.asSuperuser({ reason: 'event waiting list' }, async (su) => {
+        for (const event of events) {
+            const waiting = await (await su.model('event.registration').search({
+                where: { event, state: 'waiting' },
+                order: ['id asc'],
+            })).load({});
+            for (const r of waiting) {
+                if (!(await seatFor(su, { id: r.id, event, ticket: r.ticket?.id ?? null })))
+                    continue;
+                await su.model('event.registration').browse([r.id]).promote();
+            }
+        }
+    });
+}
+export const EventRegistration = defineModel('event.registration', {
+    label: 'Registration',
+    recName: 'name',
+    order: ['id desc'],
+    companyScoped: { required: true },
+    tracking: ['state'],
+    access: {
+        'event.user': ['read', 'write', 'create'],
+        'event.manager': [...ALL, 'export', 'import'],
+    },
+    fields: {
+        event: f.many2one('event.event', { required: true, ondelete: 'cascade' }),
+        ticket: f.many2one('event.ticket', { ondelete: 'restrict' }),
+        name: f.char({ required: true, label: 'Attendee' }),
+        email: f.char(),
+        phone: f.char(),
+        partner: f.many2one('res.partner', { ondelete: 'set null', label: 'Contact' }),
+        /** The attendee's language, for their emails. */
+        lang: f.selection({ en: 'English', bn: 'Bangla' }, { required: true, default: 'en', label: 'Language' }),
+        /** What the attendee's QR carries; checked in once with it. */
+        code: f.char({
+            required: true,
+            default: () => newCode(),
+            index: 'unique',
+            label: 'Check-in code',
+        }),
+        price: f.decimal({ scale: 2, default: '0' }),
+        checkedInAt: f.datetime({ label: 'Checked in at' }),
+        /** When the confirmation email went (once). */
+        confirmationSentAt: f.datetime({ label: 'Confirmation sent' }),
+        /** When the thanks went, after the event (once). */
+        thanksSentAt: f.datetime({ label: 'Thanks sent' }),
+        state: f.state({
+            states: {
+                draft: 'Draft',
+                confirmed: 'Confirmed',
+                waiting: 'Waiting list',
+                attended: 'Checked in',
+                cancel: 'Cancelled',
+            },
+            initial: 'draft',
+            transitions: {
+                confirm: {
+                    from: ['draft'],
+                    to: 'confirmed',
+                    // Only while the event takes registrations and has a seat; a full event offers its waiting list.
+                    guard: records('event.registration', async (registrations) => {
+                        const env = registrations.env;
+                        const refused = [];
+                        for (const r of await registrations.load({ event: true, ticket: true })) {
+                            const open = r.event.state === 'published';
+                            const saleOver = r.ticket?.saleEnd != null && String(r.ticket.saleEnd) < String(env.today());
+                            const seat = await seatFor(env, {
+                                id: r.id,
+                                event: r.event.id,
+                                ticket: r.ticket?.id ?? null,
+                            });
+                            if (!open || saleOver || !seat)
+                                refused.push(r.id);
+                        }
+                        return refused;
+                    }),
+                    message: 'No seat: the event is not open for registration, the ticket is no longer sold, or it is full (use the waiting list).',
+                    after: records('event.registration', async (registrations) => {
+                        for (const r of await registrations.load({ ticket: true }))
+                            if (r.ticket !== null)
+                                await r.write({ price: r.ticket.price });
+                        await placeConfirmed(registrations.env, registrations.ids);
+                    }),
+                },
+                wait: {
+                    from: ['draft'],
+                    to: 'waiting',
+                    guard: records('event.registration', async (registrations) => (await registrations.load({ event: true })).filter((r) => !r.event.waitingList || r.event.state !== 'published')),
+                    message: 'This event has no waiting list, or does not take registrations.',
+                },
+                /** A seat freed: the first waiting takes it. */
+                promote: {
+                    from: ['waiting'],
+                    to: 'confirmed',
+                    after: records('event.registration', async (registrations) => {
+                        for (const r of await registrations.load({ ticket: true }))
+                            if (r.ticket !== null)
+                                await r.write({ price: r.ticket.price });
+                        await placeConfirmed(registrations.env, registrations.ids);
+                    }),
+                },
+                attend: {
+                    from: ['confirmed'],
+                    to: 'attended',
+                    after: records('event.registration', async (registrations) => {
+                        await registrations.write({ checkedInAt: new Date() });
+                    }),
+                },
+                cancel: {
+                    from: ['draft', 'confirmed', 'waiting'],
+                    to: 'cancel',
+                    // A confirmed seat freed goes to the waiting list, in order.
+                    after: records('event.registration', async (registrations) => {
+                        const env = registrations.env;
+                        const events = [...new Set([...(await registrations.load({})).map((r) => r.event.id)])];
+                        await promoteWaiting(env, events);
+                    }),
+                },
+            },
+        }),
+    },
+    methods: {
+        /** Runs once these registrations hold a confirmed place. Nothing here; `event_account` invoices them. */
+        confirmed: method('event.registration', async () => undefined),
+    },
+    constraints: {
+        ticketOfTheEvent: {
+            ...check('event.registration', ['ticket', 'event'], async (registrations) => (await registrations.load({ ticket: true }))
+                .filter((r) => r.ticket !== null && r.ticket.event.id !== r.event.id)
+                .map((r) => r.id)),
+            message: 'The ticket is for another event.',
+        },
+    },
+});
+export const eventShutro = defineModule({
+    name: 'event',
+    version: '0.1.0',
+    depends: [contactsShutro, messagingShutro],
+    groups: [
+        orm.defineGroup({ code: 'event.user', label: 'Event Hub user', implies: ['contacts.user'] }),
+        orm.defineGroup({ code: 'event.manager', label: 'Event Hub manager', implies: ['event.user'] }),
+    ],
+    models: [EventEvent, EventTicket, EventSession, EventRegistration],
+});

package/dist/event/web/CheckInBox.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Check-in at the door (a node component of the event form): while the event is open, a code box — a scanner or the
+ * keyboard types into it, Enter checks in — and, where the browser reads codes, the phone's camera scanning the QR on
+ * the ticket. Each code goes to `POST /api/v1/eventhub/checkin`; the result (who, which ticket, or why not) is
+ * announced, and the form reloads its counts.
+ */
+import { type NodeComponentProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function CheckInBox({ api, record, reload }: NodeComponentProps): ReactElement | null;

package/dist/event/web/CheckInBox.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Check-in at the door (a node component of the event form): while the event is open, a code box — a scanner or the
+ * keyboard types into it, Enter checks in — and, where the browser reads codes, the phone's camera scanning the QR on
+ * the ticket. Each code goes to `POST /api/v1/eventhub/checkin`; the result (who, which ticket, or why not) is
+ * announced, and the form reloads its counts.
+ */
+import { Alert, Button, Input, Label } from '../../ui/index.js';
+import { useEffect, useId, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const readerClass = () => globalThis.BarcodeDetector;
+export function CheckInBox({ api, record, reload }) {
+    const { t } = useTranslation('event');
+    const id = useId();
+    const [code, setCode] = useState('');
+    const [result, setResult] = useState(null);
+    const [error, setError] = useState(null);
+    const [camera, setCamera] = useState(false);
+    const video = useRef(null);
+    const last = useRef(null);
+    const send = async (value) => {
+        if (value.trim() === '')
+            return;
+        try {
+            const answer = await api.call('POST', '/api/v1/eventhub/checkin', { code: value.trim() });
+            setError(null);
+            setResult(t('checkin.done', { name: answer.name, ticket: answer.ticket ?? '' }));
+            setCode('');
+            reload();
+        }
+        catch (e) {
+            setResult(null);
+            setError(e instanceof Error ? e.message : String(e));
+        }
+    };
+    // The camera: a frame read every half second; the same code is taken once every three seconds.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: restarts only when the camera is switched
+    useEffect(() => {
+        const Reader = readerClass();
+        if (!camera || Reader === undefined)
+            return;
+        let stream;
+        let timer;
+        const reader = new Reader();
+        void navigator.mediaDevices
+            .getUserMedia({ video: { facingMode: 'environment' } })
+            .then((s) => {
+            stream = s;
+            if (video.current === null)
+                return;
+            video.current.srcObject = s;
+            void video.current.play();
+            timer = setInterval(() => {
+                if (video.current === null)
+                    return;
+                void reader.detect(video.current).then((codes) => {
+                    const found = codes[0]?.rawValue;
+                    if (found === undefined)
+                        return;
+                    const now = Date.now();
+                    if (last.current?.code === found && now - last.current.at < 3000)
+                        return;
+                    last.current = { code: found, at: now };
+                    void send(found);
+                });
+            }, 500);
+        })
+            .catch((e) => {
+            setError(e instanceof Error ? e.message : String(e));
+            setCamera(false);
+        });
+        return () => {
+            if (timer !== undefined)
+                clearInterval(timer);
+            for (const track of stream?.getTracks() ?? [])
+                track.stop();
+        };
+    }, [camera]);
+    if (record === null || record['state'] !== 'published')
+        return null;
+    return (_jsxs("section", { className: "grid gap-2 rounded-md border p-3", "aria-labelledby": `${id}-title`, children: [_jsx("h3", { id: `${id}-title`, className: "text-sm font-medium", children: t('checkin.title') }), _jsxs("div", { className: "flex flex-wrap items-end gap-2", children: [_jsxs("div", { className: "grid min-w-48 flex-1 gap-1", children: [_jsx(Label, { htmlFor: `${id}-code`, children: t('checkin.code') }), _jsx(Input, { id: `${id}-code`, value: code, autoComplete: "off", onChange: (e) => setCode(e.target.value), onKeyDown: (e) => {
+                                    if (e.key !== 'Enter')
+                                        return;
+                                    e.preventDefault();
+                                    void send(code);
+                                } })] }), _jsx(Button, { type: "button", variant: "primary", onClick: () => void send(code), children: t('checkin.go') }), readerClass() === undefined ? null : (_jsx(Button, { type: "button", variant: "secondary", onClick: () => setCamera((c) => !c), children: camera ? t('checkin.stop') : t('checkin.camera') }))] }), camera ? (_jsx("video", { ref: video, className: "max-h-64 w-full rounded-md bg-black", playsInline: true, muted: true })) : null, _jsx("p", { "aria-live": "polite", className: "text-sm text-muted-foreground", children: result }), error === null ? null : _jsx(Alert, { tone: "danger", children: error })] }));
+}

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

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/event`: check-in at the door (a scanner, the keyboard or the phone's camera).
+ */
+import { type Registry } from '../../ui/index.js';
+import type { i18n } from 'i18next';
+import { messages } from './messages.js';
+export { CheckInBox } from './CheckInBox.js';
+/** Registers the component (and the messages in `i18n`, when given). */
+export declare function registerEventWeb(registry: Registry, i18n?: i18n): Registry;
+export { messages as eventMessages };

package/dist/event/web/index.js

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/event`: check-in at the door (a scanner, the keyboard or the phone's camera).
+ */
+import { addMessages } from '../../ui/index.js';
+import { CheckInBox } from './CheckInBox.js';
+import { messages } from './messages.js';
+export { CheckInBox } from './CheckInBox.js';
+/** Registers the component (and the messages in `i18n`, when given). */
+export function registerEventWeb(registry, i18n) {
+    registry.registerComponent('event.CheckIn', CheckInBox);
+    if (i18n !== undefined)
+        addMessages(i18n, 'event', messages);
+    return registry;
+}
+export { messages as eventMessages };

package/dist/event/web/messages.d.ts

@@ -0,0 +1,2 @@
+/** Messages of the Event Hub screens (namespace `event`), in English and Bangla. */
+export declare const messages: Readonly<Record<string, object>>;

package/dist/event/web/messages.js

@@ -0,0 +1,23 @@
+/** Messages of the Event Hub screens (namespace `event`), in English and Bangla. */
+export const messages = {
+    en: {
+        checkin: {
+            title: 'Check-in',
+            code: 'Ticket code',
+            go: 'Check in',
+            camera: 'Scan with the camera',
+            stop: 'Stop the camera',
+            done: '{{name}} checked in {{ticket}}',
+        },
+    },
+    bn: {
+        checkin: {
+            title: 'চেক-ইন',
+            code: 'টিকিট কোড',
+            go: 'চেক-ইন করুন',
+            camera: 'ক্যামেরায় স্ক্যান করুন',
+            stop: 'ক্যামেরা বন্ধ করুন',
+            done: '{{name}} চেক-ইন হয়েছে {{ticket}}',
+        },
+    },
+};

package/dist/event_account/.kosh/bindings.d.ts

@@ -0,0 +1,22 @@
+export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
+import { type DefinitionHelpers } from '../../server/orm.js';
+import type { DefaultLoaded, Env as CoreEnv, RecordSet as CoreRecordSet, Shutro as CoreShutro } from '../../server/orm.js';
+import type { SchemaView } from './schema.js';
+export type { SchemaView };
+/** Every model visible in this view. */
+export type ModelName = keyof SchemaView & string;
+/** `Env` typed to this view. */
+export type Env = CoreEnv<SchemaView>;
+/** `Shutro` typed to this view. */
+export type Shutro = CoreShutro<SchemaView>;
+/** A recordset of `M`, with the default loaded shape unless `L` is given. */
+export type Records<M extends ModelName, L = DefaultLoaded<SchemaView, M>> = CoreRecordSet<SchemaView, M, L>;
+export declare const compute: DefinitionHelpers<SchemaView>['compute'];
+export declare const check: DefinitionHelpers<SchemaView>['check'];
+export declare const onchange: DefinitionHelpers<SchemaView>['onchange'];
+export declare const records: DefinitionHelpers<SchemaView>['records'];
+export declare const method: DefinitionHelpers<SchemaView>['method'];
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export declare const record: DefinitionHelpers<SchemaView>['record'];
+export declare const override: DefinitionHelpers<SchemaView>['override'];
+export declare const ref: DefinitionHelpers<SchemaView>['ref'];

package/dist/event_account/.kosh/bindings.js

@@ -0,0 +1,15 @@
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 0f41dee2e33036c2
+// Bindings of module `event_account`: 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';
+/** Definition callbacks typed against this module's view: no casts in computes, checks, onchange, methods. */
+const helpers = definitions();
+export const compute = helpers.compute;
+export const check = helpers.check;
+export const onchange = helpers.onchange;
+export const records = helpers.records;
+export const method = helpers.method;
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export const record = helpers.record;
+export const override = helpers.override;
+export const ref = helpers.ref;