shutro-erp 0.3.5 → 0.3.7

package/dist/hr/module.js

@@ -58,6 +58,12 @@ export const HrDepartment = defineModel('hr.department', {
         name: f.char({ required: true }),
         parent: f.many2one('hr.department', { ondelete: 'restrict', label: 'Part of' }),
         head: f.many2one('hr.employee', { ondelete: 'set null', label: 'Head' }),
+        /** Who approves for the department (approval levels by "the approvers of the requester's department"). */
+        approvalUsers: f.many2many('res.users', {
+            relation: 'hr_department_approval_user_rel',
+            label: 'Approvers',
+            help: 'People who approve for this department when an approval level asks for the department’s approvers.',
+        }),
     },
 });
 export const HrJob = defineModel('hr.job', {
@@ -72,24 +78,83 @@ export const HrJob = defineModel('hr.job', {
         department: f.many2one('hr.department', { ondelete: 'set null' }),
     },
 });
+export const HrEmployeeTag = defineModel('hr.employee.tag', {
+    label: 'Employee tag',
+    recName: 'name',
+    order: ['name asc'],
+    archivable: true,
+    access: { 'hr.user': READ, 'hr.manager': [...ALL, 'export', 'import'] },
+    fields: {
+        name: f.char({ required: true, translate: true }),
+        color: f.integer({ default: 0, label: 'Colour' }),
+    },
+});
+/** Employment types (RFC 0032 §3.2): permanent, contractual, casual… with a code and the country they apply in. */
+export const HrContractType = defineModel('hr.contract.type', {
+    label: 'Employment type',
+    recName: 'name',
+    order: ['sequence asc', 'name asc'],
+    archivable: true,
+    access: { 'hr.user': READ, 'hr.manager': [...ALL, 'export', 'import'] },
+    fields: {
+        name: f.char({ required: true, translate: true }),
+        code: f.char({ size: 20, help: 'A short code used in reports and payroll files.' }),
+        country: f.char({
+            size: 2,
+            help: 'The country whose labour law the type follows, as its two-letter code (BD, IN); empty: any.',
+        }),
+        sequence: f.integer({ default: 10 }),
+    },
+});
 export const HrEmployee = defineModel('hr.employee', {
     label: 'Employee',
     recName: 'name',
     order: ['name asc'],
     archivable: true,
     companyScoped: { required: true },
-    tracking: ['department', 'job', 'manager'],
+    tracking: ['department', 'job', 'manager', 'unitHead', 'expenseApprover', 'leaveApprover'],
     access: { 'hr.user': READ, 'hr.manager': [...ALL, 'export', 'import'] },
     fields: {
         name: f.char({ required: true }),
+        jobTitle: f.char({
+            label: 'Job title',
+            help: 'As printed on cards and letters; the position may differ.',
+        }),
         /** The person's sign-in, when they have one. */
         user: f.many2one('res.users', { ondelete: 'set null', label: 'User' }),
         department: f.many2one('hr.department', { ondelete: 'set null' }),
         job: f.many2one('hr.job', { ondelete: 'set null', label: 'Position' }),
         manager: f.many2one('hr.employee', { ondelete: 'set null' }),
         team: f.one2many('hr.employee', 'manager', { label: 'Team' }),
+        unitHead: f.many2one('hr.employee', {
+            ondelete: 'set null',
+            label: 'Unit head',
+            help: 'The head of the person’s unit (a plant, a depot, a farm), beside the line manager; approvals may ask them.',
+        }),
+        coach: f.many2one('hr.employee', { ondelete: 'set null' }),
+        property: f.char({
+            label: 'Property',
+            help: 'The property or unit the person works for (a mill, a farm, a depot).',
+        }),
+        tags: f.many2many('hr.employee.tag', { relation: 'hr_employee_tag_rel' }),
         workEmail: f.char({ label: 'Work email' }),
         workPhone: f.char({ label: 'Work phone' }),
+        mobile: f.char({ label: 'Work mobile' }),
+        expenseApprover: f.many2one('res.users', {
+            ondelete: 'set null',
+            label: 'Expense approver',
+            help: 'Approves this person’s expense reports first (else the Spend approvers).',
+        }),
+        leaveApprover: f.many2one('res.users', {
+            ondelete: 'set null',
+            label: 'Leave approver',
+            help: 'Decides this person’s leave beside HR managers.',
+        }),
+        timezone: f.char({
+            label: 'Time zone',
+            default: 'Asia/Dhaka',
+            help: 'An IANA time zone (Asia/Dhaka, Asia/Kolkata): the person’s working hours and reminders follow it.',
+        }),
         hireDate: f.date({ label: 'Joined' }),
         // Personal: HR managers only.
         birthday: f.date({ groups: HR }),
@@ -131,11 +196,21 @@ export const HrContract = defineModel('hr.contract', {
     fields: {
         name: f.char({ required: true, label: 'Reference' }),
         employee: f.many2one('hr.employee', { required: true, ondelete: 'cascade' }),
-        kind: f.selection({ permanent: 'Permanent', fixed: 'Fixed term', probation: 'Probation', intern: 'Internship' }, { required: true, default: 'permanent', label: 'Type' }),
+        employmentType: f.many2one('hr.contract.type', {
+            ondelete: 'restrict',
+            label: 'Employment type',
+        }),
+        kind: f.selection({ permanent: 'Permanent', fixed: 'Fixed term', probation: 'Probation', intern: 'Internship' }, {
+            required: true,
+            default: 'permanent',
+            label: 'Type',
+            help: 'The kind of employment the contract is for: permanent, a fixed term, probation or an internship.',
+        }),
         dateStart: f.date({ required: true, label: 'Starts' }),
         dateEnd: f.date({ label: 'Ends' }),
         wage: f.decimal({ scale: 2, label: 'Monthly wage', groups: HR }),
         state: f.state({
+            help: 'A contract runs once started, until it is ended or cancelled.',
             states: { draft: 'Draft', running: 'Running', ended: 'Ended', cancelled: 'Cancelled' },
             initial: 'draft',
             transitions: {
@@ -180,6 +255,12 @@ export const HrLeave = defineModel('hr.leave', {
         },
         // Line managers see their team's.
         team: { groups: ['hr.user'], perms: ['read'], domain: { 'employee.manager.user': me } },
+        // The employee's leave approver decides their requests.
+        approver: {
+            groups: ['hr.user'],
+            perms: ['read', 'write'],
+            domain: { 'employee.leaveApprover': me, state: { in: ['submitted', 'approved', 'refused'] } },
+        },
         all: { groups: ['hr.manager'], perms: [...ALL], domain: {} },
     },
     fields: {
@@ -191,24 +272,23 @@ export const HrLeave = defineModel('hr.leave', {
         days: f.integer({ required: true, default: 0, label: 'Working days' }),
         reason: f.text(),
         state: f.state({
+            help: 'A request waits once submitted, and someone other than the requester approves or refuses it.',
             states: { draft: 'Draft', submitted: 'Waiting', approved: 'Approved', refused: 'Refused' },
             initial: 'draft',
             transitions: {
                 submit: { from: ['draft'], to: 'submitted' },
-                // Never by the person asking, HR managers included.
+                // Never by the person asking, HR managers included; by an HR manager or the employee's leave approver.
                 approve: {
                     from: ['submitted'],
                     to: 'approved',
-                    requires: 'hr.leave_decide',
-                    guard: records('hr.leave', (leaves) => notOwn(leaves)),
-                    message: 'Someone else decides your leave.',
+                    guard: records('hr.leave', (leaves) => undecidable(leaves)),
+                    message: 'Your own leave is decided by someone else; others’ by an HR manager or their leave approver.',
                 },
                 refuse: {
                     from: ['submitted'],
                     to: 'refused',
-                    requires: 'hr.leave_decide',
-                    guard: records('hr.leave', (leaves) => notOwn(leaves)),
-                    message: 'Someone else decides your leave.',
+                    guard: records('hr.leave', (leaves) => undecidable(leaves)),
+                    message: 'Your own leave is decided by someone else; others’ by an HR manager or their leave approver.',
                 },
                 redraft: { from: ['submitted', 'refused'], to: 'draft' },
             },
@@ -293,9 +373,10 @@ export const HrLeave = defineModel('hr.leave', {
     },
 });
 /** The leaves among `records` that the acting user asked for themself. */
-async function notOwn(records) {
+async function undecidable(records) {
     const { env, ids } = records;
-    return env.asSuperuser({ reason: 'own leave' }, async (su) => {
+    const decides = env.su || env.access.has('hr.leave_decide');
+    return env.asSuperuser({ reason: 'who decides leave' }, async (su) => {
         const leaves = (await su
             .model('hr.leave')
             .browse([...ids])
@@ -303,11 +384,14 @@ async function notOwn(records) {
         const people = new Map((await su
             .model('hr.employee')
             .browse(leaves.map((l) => l['employee']))
-            .load(['user']))
-            .read(['id', 'user'])
-            .map((e) => [e['id'], e['user']]));
+            .load(['user', 'leaveApprover']))
+            .read(['id', 'user', 'leaveApprover'])
+            .map((e) => [e['id'], e]));
         return leaves
-            .filter((l) => people.get(l['employee']) === env.uid)
+            .filter((l) => {
+            const person = people.get(l['employee']);
+            return person?.['user'] === env.uid || (!decides && person?.['leaveApprover'] !== env.uid);
+        })
             .map((l) => l['id']);
     });
 }
@@ -323,7 +407,7 @@ async function fillDays(d, env) {
 }
 export const hrShutro = defineModule({
     name: 'hr',
-    version: '0.1.0',
+    version: '0.2.0',
     depends: [contactsShutro, messagingShutro],
     groups: [
         orm.defineGroup({ code: 'hr.user', label: 'Employee', implies: ['messaging.user'] }),
@@ -340,11 +424,24 @@ export const hrShutro = defineModule({
             groups: ['hr.manager'],
         }),
     ],
-    models: [HrDepartment, HrJob, HrEmployee, HrContract, HrLeaveType, HrLeave],
+    models: [
+        HrDepartment,
+        HrJob,
+        HrEmployeeTag,
+        HrContractType,
+        HrEmployee,
+        HrContract,
+        HrLeaveType,
+        HrLeave,
+    ],
     data: [
         record('hr.leave.type', 'leave_casual', { name: 'Casual leave', daysPerYear: 10 }, { noupdate: true }),
         record('hr.leave.type', 'leave_sick', { name: 'Sick leave', daysPerYear: 14 }, { noupdate: true }),
         record('hr.leave.type', 'leave_annual', { name: 'Earned leave', daysPerYear: 20 }, { noupdate: true }),
         record('hr.leave.type', 'leave_unpaid', { name: 'Unpaid leave' }, { noupdate: true }),
+        record('hr.contract.type', 'type_permanent', { name: 'Permanent', code: 'PERM', sequence: 1 }, { noupdate: true }),
+        record('hr.contract.type', 'type_contractual', { name: 'Contractual', code: 'CONT', sequence: 2 }, { noupdate: true }),
+        record('hr.contract.type', 'type_casual', { name: 'Casual (daily)', code: 'CASU', sequence: 3 }, { noupdate: true }),
+        record('hr.contract.type', 'type_intern', { name: 'Intern', code: 'INTN', sequence: 4 }, { noupdate: true }),
     ],
 });

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

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