@gisce/ooui 0.1.0

package/src/Form.ts

@@ -0,0 +1,212 @@
+import WidgetFactory from "./WidgetFactory";
+import Container from "./Container";
+import ContainerWidget from "./ContainerWidget";
+import Widget from "./Widget";
+import { parseNodes } from "./helpers/nodeParser";
+import { evaluateAttributes } from "./helpers/attributeParser";
+import { evaluateStates, evaluateButtonStates } from "./helpers/stateParser";
+import { parseContext } from "./helpers/contextParser";
+import { parseOnChange } from "./helpers/onChangeParser";
+
+export type FormParseOptions = {
+  readOnly?: boolean;
+  values?: any;
+};
+
+class Form {
+  /**
+   * Object containing fields specification of the form.
+   */
+  _fields: any;
+  get fields() {
+    return this._fields;
+  }
+
+  _container: Container;
+  get container(): Container {
+    return this._container;
+  }
+
+  _string: string | null = null;
+  get string(): string | null {
+    return this._string;
+  }
+
+  /**
+   * Widget type
+   */
+  _type: string = "form";
+  get type(): string {
+    return this._type;
+  }
+
+  /**
+   * Determines if form is read only (default is false)
+   */
+  _readOnly: boolean = false;
+  get readOnly(): boolean {
+    return this._readOnly;
+  }
+  set readOnly(value: boolean) {
+    this._readOnly = value;
+  }
+
+  /**
+   * Context
+   */
+  _context: any = {};
+  get context(): any {
+    return this._context;
+  }
+  set context(value: any) {
+    this._context = value;
+  }
+
+  /**
+   * Collection of onChange actions for fields
+   */
+  _onChangeFields: any = {};
+  get onChangeFields(): any {
+    return this._onChangeFields;
+  }
+  set onChangeFields(value: any) {
+    this._onChangeFields = value;
+  }
+
+  /*
+  _widgets = {
+    *[Symbol.iterator]() {
+      if (this._container && this._container.length) {
+        this._container.forEach((item) => {
+
+          // yield item
+        });
+      }
+    }
+  };
+  get widgets() {
+    return this._widgets;
+  }
+  */
+
+  constructor(fields: Object, columns: number = 4) {
+    this._fields = fields;
+    this._container = new Container(columns);
+  }
+
+  parse(xml: string, options?: FormParseOptions) {
+    const { values = {}, readOnly = false } = options || {};
+
+    const parser = new DOMParser();
+    const view: Document = parser.parseFromString(xml, "text/xml");
+    this._string = view.documentElement.getAttribute("string");
+    this._readOnly = readOnly;
+    this._context = values["id"]
+      ? { active_id: values["id"], active_ids: [values["id"]] }
+      : {};
+
+    this.parseNode({
+      node: view.documentElement,
+      container: this._container,
+      values,
+    });
+  }
+
+  parseNode({
+    node,
+    container,
+    values,
+  }: {
+    node: Element;
+    container: Container;
+    values: any;
+  }) {
+    const widgetFactory = new WidgetFactory();
+
+    const nodesParsed = parseNodes(node.childNodes, this._fields);
+
+    nodesParsed.forEach((nodeParsed) => {
+      const { tag, tagAttributes, child } = nodeParsed;
+      const evaluatedTagAttributes = evaluateAttributes({
+        tagAttributes,
+        values,
+        fields: this._fields,
+      });
+
+      let evaluatedStateAttributes;
+
+      if (tag === "button" && tagAttributes.states) {
+        evaluatedStateAttributes = evaluateButtonStates({
+          states: tagAttributes.states,
+          values,
+        });
+      } else {
+        evaluatedStateAttributes = evaluateStates({
+          fieldName: tagAttributes.name,
+          values,
+          fields: this._fields,
+        });
+      }
+
+      const widgetContext = parseContext({
+        context: tagAttributes["context"] || this._fields["context"],
+        values,
+        fields: this._fields,
+      });
+
+      if (tag !== "button") {
+        this._context = { ...this._context, ...widgetContext };
+      }
+
+      if (tagAttributes["on_change"]) {
+        this._onChangeFields[tagAttributes.name] = parseOnChange(
+          tagAttributes["on_change"]
+        );
+      }
+
+      let domain: string | undefined = undefined;
+
+      if (
+        tagAttributes["domain"] &&
+        tagAttributes["domain"] !== "" &&
+        tagAttributes["domain"] !== "[]"
+      ) {
+        domain = tagAttributes["domain"];
+      }
+
+      if (
+        this._fields[tagAttributes.name] &&
+        this._fields[tagAttributes.name].domain &&
+        this._fields[tagAttributes.name].domain !== "" &&
+        this._fields[tagAttributes.name].domain !== "[]"
+      ) {
+        domain = this._fields[tagAttributes.name].domain;
+      }
+
+      const widget = widgetFactory.createWidget(tag, {
+        ...evaluatedTagAttributes,
+        ...evaluatedStateAttributes,
+        context: widgetContext,
+        domain,
+      });
+
+      if (widget instanceof ContainerWidget) {
+        this.parseNode({ node: child, container: widget.container, values });
+      }
+
+      // If the form is set to readonly, reflect it to its children
+      widget.readOnly = widget.readOnly || this.readOnly;
+      container.addWidget(widget);
+    });
+  }
+
+  /**
+   * Calls container's findById method to find the widgets matching with param id
+   * @param {string} id id to find
+   */
+  findById(id: string): Widget | null {
+    return this.container.findById(id);
+  }
+}
+
+export default Form;

package/src/Group.ts

@@ -0,0 +1,9 @@
+import ContainerWidget from "./ContainerWidget";
+
+class Group extends ContainerWidget {
+    constructor(props: any) {
+      super(props);
+    }
+}
+
+export default Group;

package/src/Image.ts

@@ -0,0 +1,8 @@
+import Field from "./Field";
+
+/**
+ * Image base64 field
+ */
+class Image extends Field {}
+
+export default Image;

package/src/Integer.ts

@@ -0,0 +1,13 @@
+import Field from "./Field";
+
+/**
+ * Integer input
+ */
+class Integer extends Field {
+
+  constructor(props?: any) {
+    super(props);
+  }
+}
+
+export default Integer;

package/src/Label.ts

@@ -0,0 +1,46 @@
+import Field from "./Field";
+
+class Label extends Field {
+  /**
+   * Label text
+   */
+  _text: string = "";
+  get text(): string {
+    return this._text;
+  }
+  set text(value: string) {
+    this._text = value;
+  }
+
+  /**
+   * Align text
+   */
+  _align: string = "left";
+  get align(): string {
+    return this._align;
+  }
+  set align(value: string) {
+    this._align = value;
+  }
+
+  /**
+   * Id of the field that this label goes with. Null if it's an independent label
+   */
+  _fieldForLabel: string | null = null;
+  get fieldForLabel(): string | null {
+    return this._fieldForLabel;
+  }
+  set fieldForLabel(value: string | null) {
+    this._fieldForLabel = value;
+  }
+
+  constructor(props?: any) {
+    super({ ...props, nolabel: true });
+
+    if (props?.fieldForLabel) {
+      this._fieldForLabel = props.fieldForLabel;
+    }
+  }
+}
+
+export default Label;

package/src/Many2many.ts

@@ -0,0 +1,59 @@
+import Field from "./Field";
+
+/**
+ * A Many2many relationship field
+ */
+class Many2many extends Field {
+  /**
+   * Field size
+   */
+  _size: number = 150;
+  get size(): number {
+    return this._size;
+  }
+  set size(value: number) {
+    this._size = value;
+  }
+
+  /**
+   * Relation
+   */
+  _relation: string = "";
+  get relation(): string {
+    return this._relation;
+  }
+  set relation(value: string) {
+    this._relation = value;
+  }
+
+  /**
+   * Must expand widget
+   */
+   _mustExpand: boolean = false;
+   get mustExpand(): boolean {
+     return this._mustExpand;
+   }
+   set mustExpand(value: boolean) {
+     this._mustExpand = value;
+   }
+
+  constructor(props: any) {
+    super(props);
+
+    if (props) {
+      if (props.size) {
+        this._size = props.size;
+      }
+
+      if (props.relation) {
+        this._relation = props.relation;
+      }
+
+      if (!props.colspan) {
+        this._mustExpand = true;
+      }
+    }
+  }
+}
+
+export default Many2many;

package/src/Many2one.ts

@@ -0,0 +1,44 @@
+import Field from "./Field";
+
+/**
+ * A many2one relationship field
+ */
+class Many2one extends Field {
+  /**
+   * Field size
+   */
+  _size: number = 150;
+  get size(): number {
+    return this._size;
+  }
+  set size(value: number) {
+    this._size = value;
+  }
+
+  /**
+   * Relation
+   */
+  _relation: string = "";
+  get relation(): string {
+    return this._relation;
+  }
+  set relation(value: string) {
+    this._relation = value;
+  }
+
+  constructor(props: any) {
+    super(props);
+
+    if (props) {
+      if (props.size) {
+        this._size = props.size;
+      }
+
+      if (props.relation) {
+        this._relation = props.relation;
+      }
+    }
+  }
+}
+
+export default Many2one;

package/src/NewLine.ts

@@ -0,0 +1,9 @@
+import Widget from "./Widget";
+
+class NewLine extends Widget {
+  findById(id: string): null {
+    return null;
+  }
+}
+
+export default NewLine;

package/src/Notebook.ts

@@ -0,0 +1,24 @@
+import ContainerWidget from "./ContainerWidget";
+
+class Notebook extends ContainerWidget {
+  static _defaultColspan: number = 3;
+  static get defaultColspan(): number {
+    return Notebook._defaultColspan;
+  }
+  static set defaultColspan(value: number) {
+    Notebook._defaultColspan = value;
+  }
+
+  constructor(props: any) {
+    super(props);
+    this.colspan = Notebook._defaultColspan;
+
+    if (props) {
+      if (props.colspan) {
+        this.colspan = props.colspan;
+      }
+    }
+  }
+}
+
+export default Notebook;

package/src/One2many.ts

@@ -0,0 +1,106 @@
+import Field from "./Field";
+
+/**
+ * A One2Many relationship field
+ */
+class One2many extends Field {
+  /**
+   * Field size
+   */
+  _size: number = 150;
+  get size(): number {
+    return this._size;
+  }
+  set size(value: number) {
+    this._size = value;
+  }
+
+  /**
+   * Relation
+   */
+  _relation: string = "";
+  get relation(): string {
+    return this._relation;
+  }
+  set relation(value: string) {
+    this._relation = value;
+  }
+
+  /**
+   * Inv_field
+   */
+  _inv_field: string | undefined;
+  get inv_field(): string | undefined {
+    return this._inv_field;
+  }
+  set inv_field(value: string | undefined) {
+    this._inv_field = value;
+  }
+
+  /**
+   * Views
+   */
+  _views: any = null;
+  get views(): any {
+    return this._views;
+  }
+  set views(value: any) {
+    this._views = value;
+  }
+
+  /**
+   * Mode
+   */
+  _mode: Array<string> = [];
+  get mode(): Array<string> {
+    return this._mode;
+  }
+  set mode(value: Array<string>) {
+    this._mode = value;
+  }
+
+  /**
+   * Must expand widget
+   */
+  _mustExpand: boolean = false;
+  get mustExpand(): boolean {
+    return this._mustExpand;
+  }
+  set mustExpand(value: boolean) {
+    this._mustExpand = value;
+  }
+
+  constructor(props: any) {
+    super(props);
+
+    if (props) {
+      if (props.size) {
+        this._size = props.size;
+      }
+
+      if (props.relation) {
+        this._relation = props.relation;
+      }
+
+      if (props.mode) {
+        this._mode = props.mode.split(",");
+      }
+
+      if (props.views) {
+        this._views = props.views;
+      }
+
+      if (props.colspan) {
+        this.colspan = props.colspan;
+      } else {
+        this._mustExpand = true;
+      }
+
+      if (props.inv_field) {
+        this._inv_field = props.inv_field;
+      }
+    }
+  }
+}
+
+export default One2many;

package/src/Page.ts

@@ -0,0 +1,9 @@
+import ContainerWidget from "./ContainerWidget";
+
+class Page extends ContainerWidget {
+  constructor(props: any) {
+    super(props);
+  }
+}
+
+export default Page;

package/src/ProgressBar.ts

@@ -0,0 +1,8 @@
+import Float from "./Float";
+
+/**
+ * ProgressBar input
+ */
+class ProgressBar extends Float {}
+
+export default ProgressBar;

package/src/Reference.ts

@@ -0,0 +1,10 @@
+import Selection from "./Selection";
+
+/**
+ * Reference field for key-value Many2One behaviour
+ */
+class Reference extends Selection {
+
+}
+
+export default Reference;

package/src/SearchFilter.ts

@@ -0,0 +1,81 @@
+import WidgetFactory from "./WidgetFactory";
+import Container from "./Container";
+import Widget from "./Widget";
+
+class SearchFilter {
+  /**
+   * Object containing the specific fields for primary and secondary search fields
+   */
+  _searchFields: any;
+  get searchFields() {
+    return this._searchFields;
+  }
+
+  /**
+   * Object containing all the fields specification of the whole form
+   */
+  _fields: any;
+  get fields() {
+    return this._fields;
+  }
+
+  _simpleSearchContainer: Container;
+  get simpleSearchContainer(): Container {
+    return this._simpleSearchContainer;
+  }
+
+  _advancedSearchContainer: Container;
+  get advancedSearchContainer(): Container {
+    return this._advancedSearchContainer;
+  }
+
+  constructor(searchFields: Object, fields: Object, columns: number = 8) {
+    this._searchFields = searchFields;
+    this._fields = fields;
+    this._simpleSearchContainer = new Container(columns);
+    this._advancedSearchContainer = new Container(columns);
+  }
+
+  parse() {
+    const widgetFactory = new WidgetFactory();
+
+    const simpleSearchWidgets = this.parseFields(
+      this.searchFields.primary,
+      widgetFactory
+    );
+    simpleSearchWidgets.forEach((widget) => {
+      this.simpleSearchContainer.addWidget(widget, { addLabel: false });
+      this.advancedSearchContainer.addWidget(widget, { addLabel: false });
+    });
+
+    const advancedSearchWidgets = this.parseFields(
+      this.searchFields.secondary,
+      widgetFactory
+    );
+    advancedSearchWidgets.forEach((widget) => {
+      this.advancedSearchContainer.addWidget(widget, { addLabel: false });
+    });
+  }
+
+  parseFields(searchFields: string[], widgetFactory: WidgetFactory) {
+    return searchFields.map((searchField) => {
+      const fieldAttributes = {
+        ...this.fields[searchField],
+        name: searchField,
+        colspan: 2,
+      };
+      const { type } = fieldAttributes;
+      return widgetFactory.createWidget(type, fieldAttributes);
+    });
+  }
+
+  /**
+   * Calls container's findById method to find the widgets matching with param id
+   * @param {string} id id to find
+   */
+  findById(id: string): Widget | null {
+    return this.advancedSearchContainer.findById(id);
+  }
+}
+
+export default SearchFilter;

package/src/Selection.ts

@@ -0,0 +1,44 @@
+import Field from "./Field";
+
+/**
+ * Selection field for key-value lists
+ */
+class Selection extends Field {
+  /**
+   * Field size
+   */
+  _size: number = 150;
+  get size(): number {
+    return this._size;
+  }
+  set size(value: number) {
+    this._size = value;
+  }
+
+  /**
+   * Values and keys
+   */
+  _selectionValues: Map<string, string> = new Map([]);
+  get selectionValues(): Map<string, string> {
+    return this._selectionValues;
+  }
+  set selectionValues(value: Map<string, string>) {
+    this._selectionValues = value;
+  }
+
+  constructor(props: any) {
+    super(props);
+
+    if (props) {
+      if (props.size) {
+        this._size = props.size;
+      }
+
+      if (props.selection) {
+        this._selectionValues = new Map(props.selection);
+      }
+    }
+  }
+}
+
+export default Selection;