@gisce/ooui 2.39.0 → 2.40.0-alpha.1

package/package.json

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

package/src/Kanban.ts

@@ -0,0 +1,285 @@
+import WidgetFactory from "./WidgetFactory";
+import Widget from "./Widget";
+import Button from "./Button";
+import { replaceEntities } from "./helpers/attributeParser";
+import { parseBoolAttribute, ParsedNode } from "./helpers/nodeParser";
+import * as txml from "txml";
+import { parseContext } from "./helpers/contextParser";
+
+export type KanbanField = Widget & {
+  sum?: string; // Aggregation label (e.g., "Total hours")
+};
+
+export type KanbanButton = Button & {
+  states?: string; // Comma-separated states where button should show
+};
+
+class Kanban {
+  /**
+   * Object containing fields specification of the kanban.
+   */
+  _fields: any;
+  get fields() {
+    return this._fields;
+  }
+
+  /**
+   * Array of field widgets to display in cards
+   */
+  _card_fields: KanbanField[] = [];
+  get card_fields(): KanbanField[] {
+    return this._card_fields;
+  }
+
+  /**
+   * Array of button widgets to display in cards
+   */
+  _buttons: KanbanButton[] = [];
+  get buttons(): KanbanButton[] {
+    return this._buttons;
+  }
+
+  _string: string | null = null;
+  get string(): string | null {
+    return this._string;
+  }
+
+  /**
+   * Widget type
+   */
+  _type: string = "kanban";
+  get type(): string {
+    return this._type;
+  }
+
+  /**
+   * Field that defines the columns (e.g., "state")
+   */
+  _column_field: string | null = null;
+  get column_field(): string | null {
+    return this._column_field;
+  }
+
+  /**
+   * Enable dragging cards between columns
+   */
+  _drag: boolean = true;
+  get drag(): boolean {
+    return this._drag;
+  }
+
+  /**
+   * Enable sorting cards within columns
+   */
+  _sort: boolean = true;
+  get sort(): boolean {
+    return this._sort;
+  }
+
+  /**
+   * Enable setting max cards per column (WIP limits)
+   */
+  _set_max_cards: boolean = false;
+  get set_max_cards(): boolean {
+    return this._set_max_cards;
+  }
+
+  /**
+   * Color expression value (e.g., "blue:state=='draft';green:state=='done'")
+   */
+  _colors: string | null = null;
+  get colors(): string | null {
+    return this._colors;
+  }
+
+  /**
+   * Context for each field in the kanban
+   */
+  _contextForFields: Record<string, any> = {};
+  get contextForFields(): Record<string, any> {
+    return this._contextForFields;
+  }
+
+  set contextForFields(value: Record<string, any>) {
+    this._contextForFields = value;
+  }
+
+  /**
+   * Map of fields that have sum aggregation
+   * Key: field name, Value: sum label (e.g., "Total hours")
+   */
+  _aggregations: Record<string, string> = {};
+  get aggregations(): Record<string, string> {
+    return this._aggregations;
+  }
+
+  constructor(fields: Object) {
+    this._fields = fields;
+  }
+
+  parse(xml: string) {
+    const view = txml
+      .parse(xml)
+      .filter((el: ParsedNode) => el.tagName === "kanban")[0];
+
+    // Parse kanban attributes
+    this._string = view.attributes.string || null;
+    if (this._string) {
+      this._string = replaceEntities(this._string);
+    }
+
+    this._column_field = view.attributes.column_field || null;
+    if (!this._column_field) {
+      throw new Error("Kanban view must have a column_field attribute");
+    }
+
+    this._drag =
+      view.attributes.drag !== undefined
+        ? parseBoolAttribute(view.attributes.drag)
+        : true;
+    this._sort =
+      view.attributes.sort !== undefined
+        ? parseBoolAttribute(view.attributes.sort)
+        : true;
+    this._set_max_cards =
+      view.attributes.set_max_cards !== undefined
+        ? parseBoolAttribute(view.attributes.set_max_cards)
+        : false;
+
+    this._colors = view.attributes.colors || null;
+    if (this._colors) {
+      this._colors = replaceEntities(this._colors);
+    }
+
+    const widgetFactory = new WidgetFactory();
+
+    // Parse children (fields and buttons)
+    view.children.forEach((element: ParsedNode) => {
+      const { tagName, attributes } = element;
+
+      if (tagName === "field") {
+        this._parseField(element, attributes, widgetFactory);
+      } else if (tagName === "button") {
+        this._parseButton(element, attributes);
+      }
+    });
+  }
+
+  private _parseField(
+    _element: ParsedNode,
+    attributes: any,
+    widgetFactory: WidgetFactory,
+  ) {
+    const { name, widget, sum } = attributes;
+
+    if (!name) {
+      return;
+    }
+
+    if (!this._fields[name]) {
+      throw new Error(`Field ${name} doesn't exist in fields definition`);
+    }
+
+    const fieldDef = this._fields[name];
+    let widgetType = fieldDef.type;
+
+    // Handle domain override
+    if (
+      ((Array.isArray(fieldDef?.domain) && fieldDef?.domain.length === 0) ||
+        fieldDef?.domain === false) &&
+      attributes.domain &&
+      attributes.domain.length > 0
+    ) {
+      delete fieldDef.domain;
+    }
+
+    // Parse context
+    const widgetContext = parseContext({
+      context: attributes.context || fieldDef.context,
+      values: {},
+      fields: this._fields,
+    });
+
+    const mergedAttrs = {
+      ...fieldDef,
+      ...attributes,
+      fieldsWidgetType: fieldDef?.type,
+      context: widgetContext,
+    };
+
+    this._contextForFields[name] = widgetContext;
+
+    // Override widget type if specified
+    if (widget) {
+      widgetType = widget;
+    }
+
+    // Create the widget
+    if (!mergedAttrs.invisible) {
+      const fieldWidget = widgetFactory.createWidget(
+        widgetType,
+        mergedAttrs,
+      ) as KanbanField;
+
+      // Handle aggregation (sum)
+      if (sum) {
+        fieldWidget.sum = replaceEntities(sum);
+        this._aggregations[name] = replaceEntities(sum);
+      }
+
+      this._card_fields.push(fieldWidget);
+    }
+  }
+
+  private _parseButton(_element: ParsedNode, attributes: any) {
+    const { name, type, string, states } = attributes;
+
+    if (!name) {
+      return;
+    }
+
+    const buttonProps = {
+      ...attributes,
+      name,
+      buttonType: type || "object",
+      string: string || "",
+    };
+
+    const button = new Button(buttonProps) as KanbanButton;
+
+    // Parse states attribute (e.g., "draft,open")
+    if (states) {
+      button.states = states;
+    }
+
+    this._buttons.push(button);
+  }
+
+  /**
+   * Find the widgets matching with param id
+   * @param {string} id id to find
+   */
+  findById(id: string): Widget | null {
+    const foundField = this._card_fields.find((item) => {
+      if (item.findById) {
+        return item.findById(id);
+      }
+      return false;
+    });
+
+    if (foundField) {
+      return foundField;
+    }
+
+    const foundButton = this._buttons.find((item) => {
+      if (item.findById) {
+        return item.findById(id);
+      }
+      return false;
+    });
+
+    return foundButton || null;
+  }
+}
+
+export default Kanban;

package/src/index.ts

@@ -1,6 +1,7 @@
 import Avatar from "./Avatar";
 import Form from "./Form";
 import Tree from "./Tree";
+import Kanban from "./Kanban";
 import Char from "./Char";
 import Container from "./Container";
 import ContainerWidget from "./ContainerWidget";
@@ -86,6 +87,7 @@ export {
   Widget,
   Form,
   Tree,
+  Kanban,
   NewLine,
   Boolean,
   One2many,

package/src/spec/Kanban.spec.ts

@@ -0,0 +1,364 @@
+import { it, expect, describe } from "vitest";
+import Kanban from "../Kanban";
+import Field from "../Field";
+import Button from "../Button";
+
+const XML_VIEW_KANBAN = `<?xml version="1.0"?>
+<kanban string="Tasks" column_field="state" drag="1" sort="1" set_max_cards="1" colors="blue:state=='draft';green:state=='done'">
+  <field name="name"/>
+  <field name="user_id" widget="avatar"/>
+  <field name="planned_hours" sum="Total hours" widget="float_time"/>
+  <field name="state"/>
+  <button name="do_open" type="object" string="Start" states="draft"/>
+  <button name="do_done" type="object" string="Complete" states="open,pending"/>
+</kanban>
+`;
+
+const XML_VIEW_KANBAN_MINIMAL = `<?xml version="1.0"?>
+<kanban column_field="status">
+  <field name="name"/>
+</kanban>
+`;
+
+const XML_VIEW_KANBAN_NO_DRAG_SORT = `<?xml version="1.0"?>
+<kanban column_field="state" drag="0" sort="0">
+  <field name="name"/>
+  <field name="priority"/>
+</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",
+  },
+  planned_hours: {
+    help: "Estimated time to complete the task",
+    string: "Planned Hours",
+    type: "float",
+    views: {},
+    widget: "float_time",
+  },
+  state: {
+    required: true,
+    readonly: true,
+    selection: [
+      ["draft", "Draft"],
+      ["open", "In Progress"],
+      ["pending", "Pending"],
+      ["cancelled", "Cancelled"],
+      ["done", "Done"],
+    ],
+    string: "State",
+    type: "selection",
+    views: {},
+  },
+  status: {
+    selection: [
+      ["new", "New"],
+      ["active", "Active"],
+      ["completed", "Completed"],
+    ],
+    string: "Status",
+    type: "selection",
+    views: {},
+  },
+  priority: {
+    selection: [
+      ["0", "Low"],
+      ["1", "Normal"],
+      ["2", "High"],
+    ],
+    string: "Priority",
+    type: "selection",
+    views: {},
+  },
+};
+
+describe("A Kanban", () => {
+  it("should parse xml with all attributes", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN);
+
+    expect(tree.type).toBe("kanban");
+    expect(tree.string).toBe("Tasks");
+    expect(tree.column_field).toBe("state");
+    expect(tree.drag).toBe(true);
+    expect(tree.sort).toBe(true);
+    expect(tree.set_max_cards).toBe(true);
+    expect(tree.colors).toBe("blue:state=='draft';green:state=='done'");
+  });
+
+  it("should parse minimal kanban xml", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN_MINIMAL);
+
+    expect(tree.type).toBe("kanban");
+    expect(tree.string).toBe(null);
+    expect(tree.column_field).toBe("status");
+    expect(tree.drag).toBe(true); // Default value
+    expect(tree.sort).toBe(true); // Default value
+    expect(tree.set_max_cards).toBe(false); // Default value
+  });
+
+  it("should parse drag and sort as false", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN_NO_DRAG_SORT);
+
+    expect(tree.drag).toBe(false);
+    expect(tree.sort).toBe(false);
+  });
+
+  it("should throw error if column_field is missing", () => {
+    const tree = new Kanban(FIELDS);
+    const invalidXml = `<?xml version="1.0"?>
+<kanban string="Invalid">
+  <field name="name"/>
+</kanban>
+`;
+
+    expect(() => tree.parse(invalidXml)).toThrow(
+      "Kanban view must have a column_field attribute",
+    );
+  });
+
+  it("should parse fields correctly", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN);
+
+    expect(tree.card_fields).toHaveLength(4);
+    expect(tree.card_fields[0].id).toBe("name");
+    expect(tree.card_fields[1].id).toBe("user_id");
+    expect(tree.card_fields[2].id).toBe("planned_hours");
+    expect(tree.card_fields[3].id).toBe("state");
+  });
+
+  it("should parse field with sum aggregation", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN);
+
+    const hoursField = tree.card_fields.find((f) => f.id === "planned_hours");
+    expect(hoursField).toBeDefined();
+    expect((hoursField as any).sum).toBe("Total hours");
+
+    expect(tree.aggregations).toHaveProperty("planned_hours");
+    expect(tree.aggregations.planned_hours).toBe("Total hours");
+  });
+
+  it("should preserve field widget attribute", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN);
+
+    const avatarField = tree.card_fields.find((f) => f.id === "user_id");
+    expect(avatarField).toBeDefined();
+    expect((avatarField as any).raw_props?.widget).toBe("avatar");
+
+    const hoursField = tree.card_fields.find((f) => f.id === "planned_hours");
+    expect(hoursField).toBeDefined();
+    expect((hoursField as any).raw_props?.widget).toBe("float_time");
+  });
+
+  it("should parse buttons correctly", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN);
+
+    expect(tree.buttons).toHaveLength(2);
+
+    const startButton = tree.buttons[0];
+    expect(startButton.id).toBe("do_open");
+    expect(startButton.buttonType).toBe("object");
+    expect(startButton.caption).toBe("Start");
+    expect((startButton as any).states).toBe("draft");
+
+    const completeButton = tree.buttons[1];
+    expect(completeButton.id).toBe("do_done");
+    expect(completeButton.buttonType).toBe("object");
+    expect(completeButton.caption).toBe("Complete");
+    expect((completeButton as any).states).toBe("open,pending");
+  });
+
+  it("should handle button without states attribute", () => {
+    const xmlWithButton = `<?xml version="1.0"?>
+<kanban column_field="state">
+  <field name="name"/>
+  <button name="action_test" type="object" string="Test"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithButton);
+
+    expect(tree.buttons).toHaveLength(1);
+    const button = tree.buttons[0];
+    expect(button.id).toBe("action_test");
+    expect((button as any).states).toBeUndefined();
+  });
+
+  it("should merge field attributes correctly", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN);
+
+    const nameField = tree.card_fields.find((f) => f.id === "name");
+    expect(nameField).toBeDefined();
+    expect(nameField?.type).toBe("char");
+    expect((nameField as any).required).toBe(true);
+    expect((nameField as any).size).toBe(128);
+  });
+
+  it("should handle context for fields", () => {
+    const xmlWithContext = `<?xml version="1.0"?>
+<kanban column_field="state">
+  <field name="user_id" context="{'show_all': True}"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithContext);
+
+    expect(tree.contextForFields).toHaveProperty("user_id");
+    expect(tree.contextForFields.user_id).toBeDefined();
+  });
+
+  it("should throw error for non-existent field", () => {
+    const xmlWithInvalidField = `<?xml version="1.0"?>
+<kanban column_field="state">
+  <field name="nonexistent_field"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+
+    expect(() => tree.parse(xmlWithInvalidField)).toThrow(
+      "Field nonexistent_field doesn't exist in fields definition",
+    );
+  });
+
+  it("should find field by id", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN);
+
+    const nameField = tree.findById("name");
+    expect(nameField).toBeDefined();
+    expect(nameField?.id).toBe("name");
+  });
+
+  it("should find button by id", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN);
+
+    const button = tree.findById("do_open");
+    expect(button).toBeDefined();
+    expect(button?.id).toBe("do_open");
+  });
+
+  it("should return null for non-existent id", () => {
+    const tree = new Kanban(FIELDS);
+    tree.parse(XML_VIEW_KANBAN);
+
+    const result = tree.findById("nonexistent");
+    expect(result).toBeNull();
+  });
+
+  it("should handle empty kanban (only column_field)", () => {
+    const emptyXml = `<?xml version="1.0"?>
+<kanban column_field="state"></kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(emptyXml);
+
+    expect(tree.card_fields).toHaveLength(0);
+    expect(tree.buttons).toHaveLength(0);
+    expect(tree.column_field).toBe("state");
+  });
+
+  it("should handle HTML entities in string attribute", () => {
+    const xmlWithEntities = `<?xml version="1.0"?>
+<kanban string="Tasks &amp; Projects" column_field="state">
+  <field name="name"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithEntities);
+
+    expect(tree.string).toBe("Tasks & Projects");
+  });
+
+  it("should handle HTML entities in colors attribute", () => {
+    const xmlWithEntities = `<?xml version="1.0"?>
+<kanban column_field="state" colors="red:priority&gt;1;blue:priority&lt;1">
+  <field name="name"/>
+  <field name="priority"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithEntities);
+
+    expect(tree.colors).toBe("red:priority>1;blue:priority<1");
+  });
+
+  it("should skip invisible fields", () => {
+    const xmlWithInvisible = `<?xml version="1.0"?>
+<kanban column_field="state">
+  <field name="name"/>
+  <field name="priority" invisible="1"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithInvisible);
+
+    expect(tree.card_fields).toHaveLength(1);
+    expect(tree.card_fields[0].id).toBe("name");
+  });
+
+  it("should handle buttons without name (skip them)", () => {
+    const xmlWithUnnamedButton = `<?xml version="1.0"?>
+<kanban column_field="state">
+  <field name="name"/>
+  <button type="object" string="Test"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithUnnamedButton);
+
+    expect(tree.buttons).toHaveLength(0);
+  });
+
+  it("should handle fields without name (skip them)", () => {
+    const xmlWithUnnamedField = `<?xml version="1.0"?>
+<kanban column_field="state">
+  <field name="name"/>
+  <field widget="custom"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithUnnamedField);
+
+    expect(tree.card_fields).toHaveLength(1);
+    expect(tree.card_fields[0].id).toBe("name");
+  });
+
+  it("should store multiple aggregations", () => {
+    const xmlWithMultipleAggs = `<?xml version="1.0"?>
+<kanban column_field="state">
+  <field name="planned_hours" sum="Total Planned"/>
+  <field name="priority" sum="Total Priority"/>
+</kanban>
+`;
+    const tree = new Kanban(FIELDS);
+    tree.parse(xmlWithMultipleAggs);
+
+    expect(Object.keys(tree.aggregations)).toHaveLength(2);
+    expect(tree.aggregations.planned_hours).toBe("Total Planned");
+    expect(tree.aggregations.priority).toBe("Total Priority");
+  });
+});