shutro-erp 0.3.6 → 0.3.7

package/dist/project/index.js

@@ -152,6 +152,129 @@ export const project = defineModule({
         category: 'Operations',
         summary: 'Projects, tasks on a kanban, timesheets',
     },
+    documents: [
+        {
+            key: 'project_plan',
+            name: 'Project plan',
+            model: 'project.plan',
+            layout: {
+                paper: 'A4',
+                header: '{{company.name}}',
+                footer: 'Page {{page}} of {{pages}}',
+                blocks: [
+                    { kind: 'heading', id: 'title', text: 'Project plan {{name}}: {{title}}', level: 1 },
+                    {
+                        kind: 'fields',
+                        id: 'plan',
+                        items: [
+                            { label: 'Type', bind: 'type.name' },
+                            { label: 'Written by', bind: 'requester.name' },
+                            { label: 'Project manager', bind: 'manager.name' },
+                            { label: 'Sponsor', bind: 'sponsor.name' },
+                            { label: 'Priority', bind: 'priority' },
+                            { label: 'Planned start', bind: 'dateStart' },
+                            { label: 'Planned end', bind: 'dateEnd' },
+                            { label: 'Estimated budget', bind: 'estimatedBudget' },
+                            { label: 'Approved budget', bind: 'approvedBudget' },
+                            { label: 'Approved on', bind: 'approvedAt' },
+                            { label: 'Status', bind: 'state' },
+                        ],
+                    },
+                    { kind: 'text', id: 'objectives', text: 'Objectives: {{objectives}}' },
+                    { kind: 'text', id: 'outcome', text: 'Expected outcome: {{expectedOutcome}}' },
+                    { kind: 'text', id: 'goal', text: 'Strategic goal: {{strategicGoal}}' },
+                    { kind: 'text', id: 'about', text: '{{description}}' },
+                    { kind: 'signature', id: 'sign', labels: ['Project manager', 'Sponsor'] },
+                ],
+            },
+        },
+    ],
+    importTemplates: [
+        {
+            key: 'project_plan',
+            model: 'project.plan',
+            label: 'Project plan',
+            columns: [
+                { header: 'Title', field: 'title' },
+                { header: 'Project type', field: 'type' },
+                { header: 'Written by', field: 'requester' },
+                { header: 'Project manager', field: 'manager' },
+                { header: 'Sponsor', field: 'sponsor' },
+                { header: 'Priority', field: 'priority' },
+                { header: 'Planned start', field: 'dateStart' },
+                { header: 'Planned end', field: 'dateEnd' },
+                { header: 'Description', field: 'description' },
+                { header: 'Objectives', field: 'objectives' },
+                { header: 'Expected outcome', field: 'expectedOutcome' },
+                { header: 'Strategic goal', field: 'strategicGoal' },
+                { header: 'Estimated budget', field: 'estimatedBudget' },
+            ],
+        },
+        {
+            key: 'project_role',
+            model: 'project.role',
+            label: 'Project role',
+            columns: [
+                { header: 'Name', field: 'name' },
+                { header: 'Code', field: 'code' },
+                { header: 'Default hourly cost', field: 'defaultHourlyCost' },
+            ],
+        },
+        {
+            key: 'project_type',
+            model: 'project.type',
+            label: 'Project type',
+            columns: [
+                { header: 'Name', field: 'name' },
+                { header: 'Code', field: 'code' },
+                { header: 'Description', field: 'description' },
+            ],
+        },
+        {
+            key: 'project_task_category',
+            model: 'project.task.category',
+            label: 'Task category',
+            columns: [
+                { header: 'Name', field: 'name' },
+                { header: 'Code', field: 'code' },
+                { header: 'Project type', field: 'type' },
+            ],
+        },
+        {
+            key: 'project_task_stage',
+            model: 'project.task.stage',
+            label: 'Task stage',
+            columns: [
+                { header: 'Name', field: 'name' },
+                { header: 'Fold', field: 'fold' },
+                { header: 'Closes the task', field: 'done' },
+            ],
+        },
+        {
+            key: 'project_project',
+            model: 'project.project',
+            label: 'Project',
+            columns: [
+                { header: 'Name', field: 'name' },
+                { header: 'Project type', field: 'type' },
+                { header: 'Programme', field: 'parentProject' },
+                { header: 'Customer', field: 'partner' },
+                { header: 'Project manager', field: 'manager' },
+                { header: 'Sponsor', field: 'sponsor' },
+                { header: 'Owner', field: 'owner' },
+                { header: 'Priority', field: 'priority' },
+                { header: 'Risk', field: 'riskLevel' },
+                { header: 'Location', field: 'location' },
+                { header: 'Phases › Name', field: 'phases.name' },
+                { header: 'Phases › Code', field: 'phases.code' },
+                { header: 'Phases › Manager', field: 'phases.manager' },
+                { header: 'Phases › Start', field: 'phases.dateStart' },
+                { header: 'Phases › End', field: 'phases.dateEnd' },
+            ],
+        },
+    ],
+    // Bangla for the labels it serves (RFC 0023 §3.1; `pnpm i18n:extract`).
+    i18n: { bn: () => import('./i18n/bn.js') },
     accessLevels: {
         user: { label: 'User (projects and tasks, own timesheets)', groups: ['project.user'] },
         manager: {

package/dist/project/module.d.ts

@@ -11362,6 +11362,16 @@ export declare const projectShutro: import("../server/orm.js").Module<readonly [
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
+    readonly lang: import("../server/orm.js").SelectionField<"bn" | "en", {
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }>;
     readonly phone: import("../server/orm.js").CharField<{
         readonly required: false;
         readonly computed: false;
@@ -11583,6 +11593,16 @@ export declare const projectShutro: import("../server/orm.js").Module<readonly [
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
+    readonly lang: import("../server/orm.js").SelectionField<"bn" | "en", {
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }>;
     readonly phone: import("../server/orm.js").CharField<{
         readonly required: false;
         readonly computed: false;

package/dist/project/module.js

@@ -399,7 +399,11 @@ export const ProjectPlan = defineModel('project.plan', {
             label: 'Sponsor',
             help: 'Approves the plan first; a Projects manager when there is none.',
         }),
-        priority: f.selection(PRIORITIES, { required: true, default: 'normal' }),
+        priority: f.selection(PRIORITIES, {
+            required: true,
+            default: 'normal',
+            help: 'How important the plan is against the others.',
+        }),
         dateStart: f.date({ label: 'Planned start' }),
         dateEnd: f.date({ label: 'Planned end' }),
         description: f.text(),
@@ -610,7 +614,11 @@ export const ProjectBudgetLine = defineModel('project.budget.line', {
         }),
         sequence: f.integer({ required: true, default: 10 }),
         name: f.char({ required: true, label: 'What for' }),
-        category: f.selection(BUDGET_CATEGORIES, { required: true, default: 'other' }),
+        category: f.selection(BUDGET_CATEGORIES, {
+            required: true,
+            default: 'other',
+            help: 'What kind of cost the line plans for.',
+        }),
         phase: f.many2one('project.phase', { ondelete: 'set null' }),
         workPackage: f.many2one('project.work.package', {
             ondelete: 'set null',
@@ -690,8 +698,17 @@ export const ProjectProject = defineModel('project.project', {
         }),
         sponsor: f.many2one('res.users', { ondelete: 'set null', label: 'Sponsor' }),
         owner: f.many2one('res.users', { ondelete: 'set null', label: 'Owner' }),
-        priority: f.selection(PRIORITIES, { required: true, default: 'normal' }),
-        riskLevel: f.selection({ low: 'Low', medium: 'Medium', high: 'High', critical: 'Critical' }, { required: true, default: 'low', label: 'Risk' }),
+        priority: f.selection(PRIORITIES, {
+            required: true,
+            default: 'normal',
+            help: 'How important the project is against the others.',
+        }),
+        riskLevel: f.selection({ low: 'Low', medium: 'Medium', high: 'High', critical: 'Critical' }, {
+            required: true,
+            default: 'low',
+            label: 'Risk',
+            help: 'How risky the project is judged to be overall.',
+        }),
         location: f.char(),
         sequence: f.integer({ required: true, default: 10 }),
         dateStart: f.date({ label: 'Start' }),
@@ -707,6 +724,7 @@ export const ProjectProject = defineModel('project.project', {
             scale: 1,
             store: true,
             label: 'Progress %',
+            help: 'How much is done, from its tasks weighted by their planned hours.',
             ...compute('project.project', 'progress', [
                 'tasks.progress',
                 'tasks.done',
@@ -730,6 +748,7 @@ export const ProjectProject = defineModel('project.project', {
             store: true,
             label: 'Budget',
             groups: MANAGERS_SEE,
+            help: 'The planned amounts of the budget lines added together.',
             ...compute('project.project', 'budget', ['budgetLines.planned'], (projects) => {
                 for (const p of projects)
                     p.budget = [...p.budgetLines].reduce((t, l) => t.plus(l.planned), orm.toDecimal(0));
@@ -764,7 +783,10 @@ export const ProjectProject = defineModel('project.project', {
             }),
         }),
         /** What the figures say (written by the refresh, hourly and on demand). */
-        healthComputed: f.selection(HEALTH, { label: 'Health by the figures' }),
+        healthComputed: f.selection(HEALTH, {
+            label: 'Health by the figures',
+            help: 'What the schedule, late milestones and costs say, checked every hour.',
+        }),
         healthNotes: f.text({ label: 'Why', help: 'What the figures said at the last refresh.' }),
         healthCheckedAt: f.datetime({ label: 'Checked' }),
         healthOverride: f.selection(HEALTH, {
@@ -775,6 +797,7 @@ export const ProjectProject = defineModel('project.project', {
         health: f.selection(HEALTH, {
             store: true,
             label: 'Health',
+            help: 'The manager’s health if set, else the health by the figures.',
             ...compute('project.project', 'health', ['healthOverride', 'healthComputed'], (projects) => {
                 for (const p of projects)
                     p.health = p.healthOverride ?? p.healthComputed ?? 'on_track';
@@ -785,6 +808,7 @@ export const ProjectProject = defineModel('project.project', {
             store: true,
             label: 'Labour cost',
             groups: MANAGERS_SEE,
+            help: 'The cost of all the hours logged on the project’s timesheets.',
             ...compute('project.project', 'labourCost', ['timesheets.cost'], (projects) => {
                 for (const p of projects) {
                     let total = orm.toDecimal(0);
@@ -806,6 +830,7 @@ export const ProjectProject = defineModel('project.project', {
             scale: 2,
             store: true,
             label: 'Hours spent',
+            help: 'The hours logged on all the project’s tasks.',
             ...compute('project.project', 'hours', ['tasks.effectiveHours'], (projects) => {
                 for (const p of projects) {
                     let total = orm.toDecimal(0);
@@ -906,7 +931,11 @@ const layerFields = {
     manager: f.many2one('res.users', { ondelete: 'set null', label: 'Manager' }),
     dateStart: f.date({ label: 'Start' }),
     dateEnd: f.date({ label: 'End' }),
-    status: f.selection(STATUSES, { required: true, default: 'draft' }),
+    status: f.selection(STATUSES, {
+        required: true,
+        default: 'draft',
+        help: 'Where the work stands, from draft to done.',
+    }),
     description: f.text(),
     /** Set by hand when the tasks do not tell the whole story (empty: computed). */
     progressOverride: f.decimal({ scale: 1, label: 'Progress set by hand %' }),
@@ -935,13 +964,18 @@ export const ProjectPhase = defineModel('project.phase', {
         responsible: f.many2one('res.users', { ondelete: 'set null' }),
         /** Its end has passed and it is not done or cancelled (set by the refresh, hourly). */
         late: f.boolean({ default: false, label: 'Late' }),
-        priority: f.selection(PRIORITIES, { required: true, default: 'normal' }),
+        priority: f.selection(PRIORITIES, {
+            required: true,
+            default: 'normal',
+            help: 'How important the phase is within its project.',
+        }),
         workPackages: f.one2many('project.work.package', 'phase', { label: 'Work packages' }),
         tasks: f.one2many('project.task', 'phase'),
         progress: f.decimal({
             scale: 1,
             store: true,
             label: 'Progress %',
+            help: 'How much is done: set by hand, else from its tasks weighted by their planned hours.',
             ...compute('project.phase', 'progress', [
                 'progressOverride',
                 'tasks.progress',
@@ -1003,6 +1037,7 @@ export const ProjectWorkPackage = defineModel('project.work.package', {
             scale: 1,
             store: true,
             label: 'Progress %',
+            help: 'How much is done: set by hand, else from its tasks weighted by their planned hours.',
             ...compute('project.work.package', 'progress', [
                 'progressOverride',
                 'tasks.progress',
@@ -1078,13 +1113,14 @@ export const ProjectTask = defineModel('project.task', {
         predecessors: f.one2many('project.task.link', 'successor', { label: 'Waits for' }),
         successors: f.one2many('project.task.link', 'predecessor', { label: 'Followed by' }),
         partner: f.many2one('res.partner', { checkCompany: true, label: 'Customer' }),
-        priority: f.selection({ normal: 'Normal', high: 'High' }, { required: true, default: 'normal' }),
+        priority: f.selection({ normal: 'Normal', high: 'High' }, { required: true, default: 'normal', help: 'How urgent the task is.' }),
         deadline: f.date(),
         plannedHours: f.decimal({ scale: 2, label: 'Planned hours' }),
         effectiveHours: f.decimal({
             scale: 2,
             store: true,
             label: 'Hours spent',
+            help: 'The hours logged on the task’s timesheets.',
             ...compute('project.task', 'effectiveHours', ['timesheets.hours'], (tasks) => {
                 for (const t of tasks) {
                     let total = orm.toDecimal(0);
@@ -1106,6 +1142,7 @@ export const ProjectTask = defineModel('project.task', {
             scale: 1,
             store: true,
             label: 'Progress %',
+            help: 'Full once done; until then, the share of its sub-tasks done, weighted by their planned hours.',
             ...compute('project.task', 'progress', ['done', 'subtasks.done', 'subtasks.plannedHours', 'subtasks.active'], (tasks) => {
                 for (const t of tasks) {
                     if (t.done) {
@@ -1141,7 +1178,11 @@ export const ProjectTask = defineModel('project.task', {
             label: 'Repeat every',
             help: 'Once done, the next one is made with its dates moved by this many days, weeks or months.',
         }),
-        repeatUnit: f.selection({ day: 'Days', week: 'Weeks', month: 'Months' }, { default: 'week', label: 'Repeat unit' }),
+        repeatUnit: f.selection({ day: 'Days', week: 'Weeks', month: 'Months' }, {
+            default: 'week',
+            label: 'Repeat unit',
+            help: 'Whether the repeat is counted in days, weeks or months.',
+        }),
         repeatUntil: f.date({ label: 'Repeat until' }),
         nextTask: f.many2one('project.task', { ondelete: 'set null', label: 'Next one' }),
     },
@@ -1295,7 +1336,7 @@ export const ProjectRisk = defineModel('project.risk', {
             safety: 'Safety',
             supply: 'Supply',
             other: 'Other',
-        }, { required: true, default: 'other' }),
+        }, { required: true, default: 'other', help: 'What part of the project the risk threatens.' }),
         probability: f.integer({
             required: true,
             default: 3,
@@ -1317,6 +1358,7 @@ export const ProjectRisk = defineModel('project.risk', {
         level: f.selection(RISK_LEVELS, {
             store: true,
             label: 'Level',
+            help: 'From the probability times the impact: up to 4 low, 9 medium, 15 high, above that critical.',
             ...compute('project.risk', 'level', ['probability', 'impact'], (risks) => {
                 for (const r of risks)
                     r.level = riskLevel((r.probability ?? 0) * (r.impact ?? 0));
@@ -1329,7 +1371,11 @@ export const ProjectRisk = defineModel('project.risk', {
         mitigation: f.text({ help: 'What is done to make it less likely or less bad.' }),
         contingency: f.text({ help: 'What is done if it happens.' }),
         dueDate: f.date({ label: 'Review by' }),
-        status: f.selection({ open: 'Open', mitigating: 'Being mitigated', occurred: 'Occurred', closed: 'Closed' }, { required: true, default: 'open' }),
+        status: f.selection({ open: 'Open', mitigating: 'Being mitigated', occurred: 'Occurred', closed: 'Closed' }, {
+            required: true,
+            default: 'open',
+            help: 'Where the risk stands: open, being dealt with, happened or closed.',
+        }),
     },
     sqlConstraints: {
         scale: {
@@ -1354,7 +1400,11 @@ export const ProjectIssue = defineModel('project.issue', {
         }),
         name: f.char({ required: true, label: 'Issue' }),
         description: f.text(),
-        severity: f.selection(RISK_LEVELS, { required: true, default: 'medium' }),
+        severity: f.selection(RISK_LEVELS, {
+            required: true,
+            default: 'medium',
+            help: 'How serious the issue is for the project.',
+        }),
         raisedBy: f.many2one('res.users', {
             default: (env) => env.userId,
             ondelete: 'set null',
@@ -1362,7 +1412,11 @@ export const ProjectIssue = defineModel('project.issue', {
         }),
         owner: f.many2one('res.users', { ondelete: 'set null' }),
         dueDate: f.date({ label: 'Resolve by' }),
-        status: f.selection({ open: 'Open', in_progress: 'In progress', resolved: 'Resolved', closed: 'Closed' }, { required: true, default: 'open' }),
+        status: f.selection({ open: 'Open', in_progress: 'In progress', resolved: 'Resolved', closed: 'Closed' }, {
+            required: true,
+            default: 'open',
+            help: 'Where the issue stands, from open to resolved and closed.',
+        }),
         resolution: f.text(),
         risk: f.many2one('project.risk', { ondelete: 'set null', label: 'From the risk' }),
     },
@@ -1548,7 +1602,10 @@ export const ProjectStatusReport = defineModel('project.status.report', {
             default: (env) => env.userId,
             ondelete: 'restrict',
         }),
-        health: f.selection(HEALTH, { label: 'Health then' }),
+        health: f.selection(HEALTH, {
+            label: 'Health then',
+            help: 'The project’s health when the report was written.',
+        }),
         progress: f.decimal({ scale: 1, label: 'Progress then %' }),
         done: f.text({ label: 'Done this week' }),
         next: f.text({ label: 'Next week' }),
@@ -1557,6 +1614,7 @@ export const ProjectStatusReport = defineModel('project.status.report', {
         state: f.state({
             states: { draft: 'Draft', sent: 'Sent' },
             initial: 'draft',
+            help: 'A draft can still be edited; once sent, it is posted on the project for its followers.',
             transitions: {
                 send: {
                     from: ['draft'],
@@ -1660,6 +1718,7 @@ export const ProjectTimesheet = defineModel('project.timesheet', {
             store: true,
             label: 'Cost',
             groups: MANAGERS_SEE,
+            help: 'The hours at the person’s hourly cost in the project that day, else their role’s.',
             ...compute('project.timesheet', 'cost', [
                 'hours',
                 'user',

package/dist/project_account/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 10e55beb4eefea56
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 34d960bd13bde47f
 // Bindings of module `project_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';