@gisce/ooui 2.40.0-alpha.6 → 2.40.0-alpha.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gisce/ooui",
-  "version": "2.40.0-alpha.6",
+  "version": "2.40.0-alpha.8",
   "engines": {
     "node": "20.5.0"
   },

package/src/Kanban.ts

@@ -5,6 +5,7 @@ import { replaceEntities } from "./helpers/attributeParser";
 import { parseBoolAttribute, ParsedNode } from "./helpers/nodeParser";
 import * as txml from "txml";
 import { parseContext } from "./helpers/contextParser";
+import { parseOnChange } from "./helpers/onChangeParser";
 
 export type KanbanField = Widget & {
   sum?: string; // Aggregation label (e.g., "Total hours")
@@ -106,6 +107,16 @@ class Kanban {
     return this._colors;
   }
 
+  /**
+   * Custom function to call when a card moves between columns
+   * Example: "handle_state_change" or with args "handle_state_change(field, from, to)"
+   * If not defined, the frontend should use the default on_change_column method
+   */
+  _on_change_column: { method: string; args: string[] } | null = null;
+  get on_change_column(): { method: string; args: string[] } | null {
+    return this._on_change_column;
+  }
+
   /**
    * Context for each field in the kanban
    */
@@ -165,6 +176,11 @@ class Kanban {
       this._status = replaceEntities(this._status);
     }
 
+    // Parse on_change_column attribute
+    if (view.attributes.on_change_column) {
+      this._on_change_column = parseOnChange(view.attributes.on_change_column);
+    }
+
     const widgetFactory = new WidgetFactory();
 
     // Parse children (fields and buttons)

package/src/KanbanCard.ts

@@ -0,0 +1,84 @@
+import WidgetFactory from "./WidgetFactory";
+import Container from "./Container";
+import Kanban from "./Kanban";
+import { evaluateButtonStates } from "./helpers/stateParser";
+import { evaluateAttributes } from "./helpers/attributeParser";
+import Button from "./Button";
+
+export type KanbanCardParseOptions = {
+  readOnly?: boolean;
+};
+
+class KanbanCard {
+  _kanbanDef: Kanban;
+  get kanbanDef(): Kanban {
+    return this._kanbanDef;
+  }
+
+  constructor(kanbanDef: Kanban) {
+    this._kanbanDef = kanbanDef;
+  }
+
+  parse(record: any, options?: KanbanCardParseOptions): Container {
+    const readOnly = options?.readOnly ?? false;
+    const container = new Container(1, 12, readOnly);
+    const widgetFactory = new WidgetFactory();
+    let keyIdx = 0;
+
+    this._kanbanDef.card_fields.forEach((field: any) => {
+      keyIdx++;
+
+      const evaluatedAttrs = evaluateAttributes({
+        tagAttributes: field.raw_props || {},
+        values: record,
+        fields: this._kanbanDef.fields,
+        widgetType: field.type || "field",
+      });
+
+      // Extract properties from the existing field widget
+      const widgetProps = {
+        ...(field.raw_props || {}),
+        ...evaluatedAttrs,
+        key: `field_${keyIdx}`,
+      };
+
+      if (readOnly) {
+        widgetProps.readonly = true;
+      }
+
+      // Determine widget type from the field
+      const widgetType = field.type || "field";
+      const widget = widgetFactory.createWidget(widgetType, widgetProps);
+      container.addWidget(widget, { addLabel: !field.nolabel });
+    });
+
+    // Add buttons to container
+    this._kanbanDef.buttons.forEach((button: any) => {
+      keyIdx++;
+
+      const evaluatedStates = button.states
+        ? evaluateButtonStates({
+            states: button.states,
+            values: record,
+          })
+        : {};
+
+      const buttonProps = {
+        ...(button.raw_props || {}),
+        ...evaluatedStates,
+        key: `button_${keyIdx}`,
+      };
+
+      if (readOnly) {
+        buttonProps.readonly = true;
+      }
+
+      const buttonWidget = new Button(buttonProps);
+      container.addWidget(buttonWidget, { addLabel: false });
+    });
+
+    return container;
+  }
+}
+
+export default KanbanCard;

package/src/helpers/onChangeParser.ts

@@ -3,7 +3,14 @@ const parseOnChange = (onChangeString: string) => {
 
   const method = splitted[0];
   const argsGross = splitted[1];
-  const argsSplitted = argsGross.split(",").map((arg) => arg.trim());
+
+  // Handle case where there are no parentheses (no arguments)
+  const argsSplitted = argsGross
+    ? argsGross
+        .split(",")
+        .map((arg) => arg.trim())
+        .filter((arg) => arg.length > 0)
+    : [];
 
   return {
     method,

package/src/index.ts

@@ -2,6 +2,7 @@ import Avatar from "./Avatar";
 import Form from "./Form";
 import Tree from "./Tree";
 import Kanban from "./Kanban";
+import KanbanCard from "./KanbanCard";
 import Char from "./Char";
 import Container from "./Container";
 import ContainerWidget from "./ContainerWidget";
@@ -89,6 +90,7 @@ export {
   Form,
   Tree,
   Kanban,
+  KanbanCard,
   NewLine,
   Boolean,
   One2many,

package/src/spec/Kanban.spec.ts

@@ -360,4 +360,43 @@ describe("A Kanban", () => {
     expect(tree.aggregations.planned_hours).toBe("Total Planned");
     expect(tree.aggregations.priority).toBe("Total Priority");
   });
+
+  it("should parse on_change_column attribute with simple method name", () => {
+    const xmlWithOnChange = `<?xml version="1.0"?>
+<kanban column_field="state" on_change_column="handle_state_change">
+  <field name="name"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithOnChange);
+
+    expect(tree.on_change_column).toBeDefined();
+    expect(tree.on_change_column?.method).toBe("handle_state_change");
+    expect(tree.on_change_column?.args).toHaveLength(0);
+  });
+
+  it("should parse on_change_column attribute with method and arguments", () => {
+    const xmlWithOnChangeArgs = `<?xml version="1.0"?>
+<kanban column_field="state" on_change_column="handle_column_change(field, from_column, to_column, context)">
+  <field name="name"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithOnChangeArgs);
+
+    expect(tree.on_change_column).toBeDefined();
+    expect(tree.on_change_column?.method).toBe("handle_column_change");
+    expect(tree.on_change_column?.args).toHaveLength(4);
+    expect(tree.on_change_column?.args[0]).toBe("field");
+    expect(tree.on_change_column?.args[1]).toBe("from_column");
+    expect(tree.on_change_column?.args[2]).toBe("to_column");
+    expect(tree.on_change_column?.args[3]).toBe("context");
+  });
+
+  it("should return null for on_change_column when not defined", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN_MINIMAL);
+
+    expect(tree.on_change_column).toBeNull();
+  });
 });

package/src/spec/kanbanCard.spec.ts

@@ -0,0 +1,217 @@
+import { it, expect, describe } from "vitest";
+import Kanban from "../Kanban";
+import KanbanCard from "../KanbanCard";
+import Button from "../Button";
+import Field from "../Field";
+
+const XML_VIEW_KANBAN = `<?xml version="1.0"?>
+<kanban string="Tasks" column_field="state" drag="1">
+  <field name="name"/>
+  <field name="user_id" widget="avatar"/>
+  <field name="state"/>
+  <button name="do_open" type="object" string="Start" states="draft"/>
+  <button name="do_done" type="object" string="Complete" states="open,pending"/>
+  <button name="action_always" type="object" string="Always Visible"/>
+</kanban>
+`;
+
+const FIELDS = {
+  name: {
+    required: true,
+    size: 128,
+    string: "Task Summary",
+    type: "char",
+    views: {},
+  },
+  user_id: {
+    context: "",
+    domain: [],
+    relation: "res.users",
+    size: 64,
+    string: "Assigned to",
+    type: "many2one",
+    views: {},
+    widget: "avatar",
+  },
+  state: {
+    required: true,
+    readonly: true,
+    selection: [
+      ["draft", "Draft"],
+      ["open", "In Progress"],
+      ["pending", "Pending"],
+      ["cancelled", "Cancelled"],
+      ["done", "Done"],
+    ],
+    string: "State",
+    type: "selection",
+    views: {},
+  },
+};
+
+describe("A KanbanCard", () => {
+  it("should parse and create a Container", () => {
+    const kanbanDef = new Kanban(FIELDS);
+    kanbanDef.parse(XML_VIEW_KANBAN);
+
+    const record = {
+      id: 1,
+      name: "Test Task",
+      user_id: [1, "John Doe"],
+      state: "draft",
+    };
+
+    const container = new KanbanCard(kanbanDef).parse(record);
+
+    expect(container).toBeDefined();
+    expect(container.rows).toBeDefined();
+    expect(container.rows.length).toBeGreaterThan(0);
+  });
+
+  it("should show button when record state matches button states", () => {
+    const kanbanDef = new Kanban(FIELDS);
+    kanbanDef.parse(XML_VIEW_KANBAN);
+
+    const record = {
+      id: 1,
+      name: "Test Task",
+      state: "draft", // Matches states="draft" in do_open button
+    };
+
+    const container = new KanbanCard(kanbanDef).parse(record);
+
+    // Find all buttons in the container
+    const buttons = container.rows.flat().filter((w) => w instanceof Button);
+
+    // Find the "do_open" button
+    const doOpenButton = buttons.find((b) => b.id === "do_open");
+    expect(doOpenButton).toBeDefined();
+    expect(doOpenButton!.invisible).toBe(false);
+  });
+
+  it("should hide button when record state doesn't match button states", () => {
+    const kanbanDef = new Kanban(FIELDS);
+    kanbanDef.parse(XML_VIEW_KANBAN);
+
+    const record = {
+      id: 1,
+      name: "Test Task",
+      state: "open", // Does NOT match states="draft" in do_open button
+    };
+
+    const container = new KanbanCard(kanbanDef).parse(record);
+
+    // Find all buttons in the container
+    const buttons = container.rows.flat().filter((w) => w instanceof Button);
+
+    // Find the "do_open" button
+    const doOpenButton = buttons.find((b) => b.id === "do_open");
+    expect(doOpenButton).toBeDefined();
+    expect(doOpenButton!.invisible).toBe(true);
+  });
+
+  it("should always show button without states attribute", () => {
+    const kanbanDef = new Kanban(FIELDS);
+    kanbanDef.parse(XML_VIEW_KANBAN);
+
+    const record = {
+      id: 1,
+      name: "Test Task",
+      state: "done", // Any state
+    };
+
+    const container = new KanbanCard(kanbanDef).parse(record);
+
+    // Find all buttons in the container
+    const buttons = container.rows.flat().filter((w) => w instanceof Button);
+
+    // Find the "action_always" button (has no states attribute)
+    const alwaysButton = buttons.find((b) => b.id === "action_always");
+    expect(alwaysButton).toBeDefined();
+    expect(alwaysButton!.invisible).toBe(false);
+  });
+
+  it("should show button when state matches one of multiple comma-separated states", () => {
+    const kanbanDef = new Kanban(FIELDS);
+    kanbanDef.parse(XML_VIEW_KANBAN);
+
+    const record = {
+      id: 1,
+      name: "Test Task",
+      state: "pending", // Matches one of states="open,pending" in do_done button
+    };
+
+    const container = new KanbanCard(kanbanDef).parse(record);
+
+    const buttons = container.rows.flat().filter((w) => w instanceof Button);
+    const doDoneButton = buttons.find((b) => b.id === "do_done");
+    expect(doDoneButton).toBeDefined();
+    expect(doDoneButton!.invisible).toBe(false);
+  });
+
+  it("should add fields to container", () => {
+    const kanbanDef = new Kanban(FIELDS);
+    kanbanDef.parse(XML_VIEW_KANBAN);
+
+    const record = {
+      id: 1,
+      name: "Test Task",
+      user_id: [1, "John Doe"],
+      state: "draft",
+    };
+
+    const container = new KanbanCard(kanbanDef).parse(record);
+
+    // Find all fields in the container
+    const fields = container.rows.flat().filter((w) => w instanceof Field);
+
+    expect(fields.length).toBeGreaterThan(0);
+
+    // Check that the name field exists
+    const nameField = fields.find((f) => f.id === "name");
+    expect(nameField).toBeDefined();
+  });
+
+  it("should respect readOnly option", () => {
+    const kanbanDef = new Kanban(FIELDS);
+    kanbanDef.parse(XML_VIEW_KANBAN);
+
+    const record = {
+      id: 1,
+      name: "Test Task",
+      state: "draft",
+    };
+
+    const container = new KanbanCard(kanbanDef).parse(record, {
+      readOnly: true,
+    });
+
+    expect(container.readOnly).toBe(true);
+
+    // Check that buttons inherit readOnly
+    const buttons = container.rows.flat().filter((w) => w instanceof Button);
+    buttons.forEach((button) => {
+      expect(button.readOnly).toBe(true);
+    });
+  });
+
+  it("should handle record without state field gracefully", () => {
+    const kanbanDef = new Kanban(FIELDS);
+    kanbanDef.parse(XML_VIEW_KANBAN);
+
+    const record = {
+      id: 1,
+      name: "Test Task",
+      // state field is missing
+    };
+
+    const container = new KanbanCard(kanbanDef).parse(record);
+
+    // Should not throw error and should create container
+    expect(container).toBeDefined();
+
+    // Buttons should handle undefined state gracefully
+    const buttons = container.rows.flat().filter((w) => w instanceof Button);
+    expect(buttons.length).toBeGreaterThan(0);
+  });
+});