shutro-erp 0.3.5 → 0.3.6

package/dist/payroll/routes.js

@@ -0,0 +1,112 @@
+/**
+ * Payroll's routes (RFC 0024 §2.3):
+ *
+ * - `POST /api/v1/payroll/formula`                   `{ formula }`: whether it parses, and the variables it reads
+ * - `POST /api/v1/payroll/runs/:id/correction`       managers: a correction run of an approved run (computed)
+ * - `GET  /api/v1/payroll/payment-formats`           the payment file formats
+ * - `GET  /api/v1/payroll/runs/:id/payment-file?format=`  officers: an approved run's file (bank, bkash, nagad…)
+ */
+import { audit, HttpProblem } from '../server/index.js';
+import { isoDate, PAYMENT_FORMATS, paymentRows } from './compute.js';
+import { FormulaError, parse, variablesOf } from './formula.js';
+const officer = (env) => env.administrator || env.groups.has('payroll.officer');
+export function registerPayrollRoutes({ app }) {
+    app.post('/api/v1/payroll/formula', async (request) => {
+        const formula = request.body?.['formula'];
+        if (typeof formula !== 'string')
+            throw new HttpProblem(422, 'invalid-formula', 'Invalid formula', 'Send { formula }.');
+        return request.env(async (raw) => {
+            if (!officer(raw))
+                throw new HttpProblem(403, 'access', 'Payroll officers', 'This needs the Payroll officer role.');
+            try {
+                return { ok: true, variables: [...new Set(variablesOf(parse(formula)))].sort() };
+            }
+            catch (error) {
+                if (error instanceof FormulaError)
+                    return { ok: false, error: error.message };
+                throw error;
+            }
+        });
+    });
+    app.post('/api/v1/payroll/runs/:id/correction', async (request, reply) => {
+        const id = Number(request.params.id);
+        return request.env(async (raw) => {
+            const env = raw;
+            if (!env.administrator && !env.access.has('payroll.approve'))
+                throw new HttpProblem(403, 'access', 'Payroll managers', 'Corrections are made by payroll managers.');
+            const made = await env.asSuperuser({ reason: 'payroll correction' }, async (su) => {
+                const [run] = await su
+                    .model('payroll.run')
+                    .browse([id])
+                    .load({ company: true });
+                if (run === undefined)
+                    throw new HttpProblem(404, 'missing-record', 'Not found', `There is no run ${id}.`);
+                if (run.state !== 'approved' && run.state !== 'paid')
+                    throw new HttpProblem(409, 'not-approved', 'Not approved', 'Only an approved run is corrected.');
+                const created = await su.model('payroll.run').create([
+                    {
+                        title: `Correction of ${run.name}`,
+                        kind: 'correction',
+                        correctionOf: run.id,
+                        company: run.company.id,
+                        dateFrom: isoDate(run.dateFrom),
+                        dateTo: isoDate(run.dateTo),
+                    },
+                ]);
+                await su.flush();
+                // Computed like any run (the compute step fills the payslips with the differences).
+                await su.model('payroll.run').browse(created.ids).compute();
+                await audit(env, {
+                    kind: 'payroll.correction',
+                    summary: `A correction of ${run.name}.`,
+                    targetModel: 'payroll.run',
+                    targetId: created.ids[0],
+                    ip: request.ip,
+                });
+                await su.flush();
+                return created.ids[0];
+            });
+            return reply.code(201).send({ id: made });
+        }, { write: true });
+    });
+    app.get('/api/v1/payroll/payment-formats', async () => ({
+        formats: PAYMENT_FORMATS.map((f) => ({ key: f.key, label: f.label })),
+    }));
+    app.get('/api/v1/payroll/runs/:id/payment-file', async (request, reply) => {
+        const id = Number(request.params.id);
+        const format = PAYMENT_FORMATS.find((f) => f.key === request.query.format);
+        if (format === undefined)
+            throw new HttpProblem(422, 'invalid-format', 'Invalid format', `Choose one of: ${PAYMENT_FORMATS.map((f) => f.key).join(', ')}.`);
+        const out = await request.env(async (raw) => {
+            const env = raw;
+            if (!officer(env))
+                throw new HttpProblem(403, 'access', 'Payroll officers', 'This needs the Payroll officer role.');
+            return env.asSuperuser({ reason: 'payroll payment file' }, async (su) => {
+                const [run] = await su
+                    .model('payroll.run')
+                    .browse([id])
+                    .load(['name', 'state']);
+                if (run === undefined)
+                    throw new HttpProblem(404, 'missing-record', 'Not found', `There is no run ${id}.`);
+                if (run.state !== 'approved' && run.state !== 'paid')
+                    throw new HttpProblem(409, 'not-approved', 'Not approved', 'Payment files come from approved runs.');
+                const rows = (await paymentRows(su, id)).filter(format.takes);
+                await audit(env, {
+                    kind: 'payroll.payment_file',
+                    summary: `${format.label} of ${run.name}: ${rows.length} payments.`,
+                    targetModel: 'payroll.run',
+                    targetId: id,
+                    ip: request.ip,
+                });
+                return {
+                    name: `${run.name.replace(/[^\w-]+/g, '_')}-${format.key}.csv`,
+                    text: format.render(rows),
+                };
+            });
+        }, { write: true });
+        return reply
+            .header('content-type', 'text/csv; charset=utf-8')
+            .header('content-disposition', `attachment; filename="${out.name}"`)
+            .send(out.text);
+    });
+}

package/dist/payroll_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/payroll_account/.kosh/bindings.js

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