@sankhyalabs/sankhyablocks 1.3.33 → 1.4.0-beta.1

package/dist/collection/components/snk-data-unit/snk-data-unit.js

@@ -0,0 +1,544 @@
+import { Host, h } from '@stencil/core';
+import { Action, ApplicationContext } from '@sankhyalabs/core';
+import { ApplicationUtils, DialogType } from '@sankhyalabs/ezui/dist/collection/utils';
+import { OperationMap } from '../../lib/message/SnkMessageBuilder';
+export class SnkDataUnit {
+  constructor() {
+    this._onDataUnitResolve = [];
+    /**
+     * Determina quantas linhas são retornadas por página
+     */
+    this.pageSize = 150;
+    /**
+     * Quando ativada essa propriedade faz com que haja uma carga imediata no DataUnit
+     */
+    this.autoLoad = true;
+    this._dataUnitObserver = (action) => {
+      const duState = {
+        insertionMode: false,
+        hasNext: this.dataUnit.hasNext(),
+        hasPrevious: this.dataUnit.hasPrevious(),
+        copyMode: false,
+        isDirty: this.dataUnit.isDirty(),
+        hasDirtyRecords: this.dataUnit.hasDirtyRecords(),
+        selectedRecords: this.dataUnit.getSelectedRecords()
+      };
+      this.dataUnit.records.forEach(r => {
+        if (r.__record__id__.startsWith('NEW_')) {
+          duState.insertionMode = true;
+          duState.copyMode || (duState.copyMode = r['__record__source__id__'] != undefined);
+        }
+      });
+      this.dataState = duState;
+      if (action.type === Action.DATA_SAVED) {
+        const msg = this.getMessage("snkDataUnit.saveInfo", action.payload.records[0]);
+        if (msg != undefined) {
+          this.showSuccessMessage(msg);
+        }
+      }
+      if (action.type === Action.RECORDS_ADDED || action.type === Action.RECORDS_COPIED) {
+        this.insertionMode.emit();
+      }
+      if (action.type === Action.EDITION_CANCELED) {
+        this.cancelEdition.emit();
+        const cancelFinishMsg = this.getMessage("snkDataUnit.cancelInfo");
+        if (cancelFinishMsg != undefined) {
+          this.showSuccessMessage(cancelFinishMsg);
+        }
+      }
+      if (action.type === Action.RECORDS_REMOVED) {
+        const removeFinishMsg = this.getMessage("snkDataUnit.removeInfo", action.payload.cachedRecords[0]);
+        if (removeFinishMsg != undefined) {
+          this.showSuccessMessage(removeFinishMsg);
+        }
+      }
+      this._application.messagesBuilder.currentOperation = this.getMessageOperation();
+    };
+  }
+  observePageSize() {
+    if (this.dataUnit) {
+      this.dataUnit.pageSize = this.pageSize;
+    }
+  }
+  observeDataUnitName(newValue, oldValue) {
+    if (oldValue != newValue) {
+      this.dataUnit = undefined;
+      this.dataUnitName = newValue;
+      this.loadDataUnit();
+    }
+  }
+  observeEntityName(newValue, oldValue) {
+    if (oldValue != newValue) {
+      this.dataUnit = undefined;
+      this.entityName = newValue;
+      this.loadDataUnit();
+    }
+  }
+  observeDataState(newValue, oldValue) {
+    if (oldValue != newValue) {
+      this.dataStateChange.emit(newValue);
+    }
+  }
+  observeDataUnit() {
+    this.dataUnitReady.emit(this.dataUnit);
+  }
+  /**
+   * Pode-se obter o dataUnit através desse método. Outra forma, é ouvir o evento de
+   *
+   * @returns dataUnit
+   */
+  async getDataUnit() {
+    return new Promise((resolve) => {
+      if (this.dataUnit) {
+        resolve(this.dataUnit);
+      }
+      else {
+        this._onDataUnitResolve.push(resolve);
+      }
+    });
+  }
+  async interceptAction(action) {
+    return new Promise(resolve => {
+      switch (action.type) {
+        case Action.RECORDS_ADDED:
+          if (this.isAllowed("INSERT")) {
+            resolve(action);
+          }
+          else {
+            ApplicationUtils.info(this.getMessage("snkDataUnit.forbiddenInsert"));
+          }
+          break;
+        case Action.RECORDS_COPIED:
+          if (this.isAllowed("CLONE")) {
+            resolve(action);
+          }
+          else {
+            ApplicationUtils.info(this.getMessage("snkDataUnit.forbiddenClone"));
+          }
+          break;
+        case Action.DATA_CHANGED:
+        case Action.CHANGING_DATA:
+          if (this.isAllowed("UPDATE")) {
+            resolve(action);
+          }
+          else {
+            this.dataUnit.cancelEdition();
+            ApplicationUtils.alert(this.getMessage("snkDataUnit.forbidden"), this.getMessage("snkDataUnit.forbiddenUpdate"));
+          }
+          break;
+        case Action.SAVING_DATA:
+          if (this.beforeSave) {
+            const continueAction = this.beforeSave(this.dataUnit);
+            if (continueAction instanceof Promise) {
+              continueAction.then(result => resolve(result ? action : undefined));
+            }
+            else {
+              resolve(continueAction ? action : undefined);
+            }
+          }
+          else {
+            resolve(action);
+          }
+          break;
+        case Action.DATA_SAVED:
+          if (this.afterSave) {
+            this.afterSave(this.dataUnit);
+          }
+          else {
+            resolve(action);
+          }
+          break;
+        case Action.EDITION_CANCELED:
+          if (this.dataState.hasDirtyRecords) {
+            const cancelConfirmation = this.getMessage("snkDataUnit.cancelConfirmation");
+            if (cancelConfirmation == undefined) {
+              resolve(action);
+            }
+            else {
+              const cancelConfirmationTitle = this.getMessage("snkDataUnit.cancelConfirmationTitle");
+              ApplicationUtils.confirm(cancelConfirmationTitle, cancelConfirmation)
+                .then((result) => resolve(result ? action : undefined));
+            }
+          }
+          else {
+            resolve(action);
+          }
+          break;
+        case Action.REMOVING_RECORDS:
+          if (this.isAllowed("REMOVE")) {
+            const removeConfirmation = this.getMessage("snkDataUnit.removeConfirmation");
+            if (removeConfirmation == undefined) {
+              resolve(action);
+            }
+            else {
+              const removeConfirmationTitle = this.getMessage("snkDataUnit.removeConfirmationTitle");
+              ApplicationUtils.confirm(removeConfirmationTitle, removeConfirmation, "delete", DialogType.CRITICAL, { btnConfirmDanger: true })
+                .then((result) => resolve(result ? action : undefined));
+            }
+          }
+          else {
+            ApplicationUtils.info(this.getMessage("snkDataUnit.forbiddenRemove"));
+          }
+          break;
+        default:
+          resolve(action);
+      }
+    });
+  }
+  showSuccessMessage(message) {
+    ApplicationUtils.info(message, { iconName: "check" });
+  }
+  isAllowed(flag) {
+    return this._permissions ? this._permissions.isSup || this._permissions[flag] : false;
+  }
+  /**
+   * Conforme mecanismo de mensagens, é possível customizar as mensagens dos blocos de construção
+   * através de um pequeno modulo na estrutura da aplicação:
+   * - Criar um arquivo no seguinte caminho: /messages/appmessages.msg.js.
+   * Para conhecer os detalhes do módulo, vide o arquivo neste projeto "/src/lib/message/resources/snk-data-unit.msg.ts"
+   */
+  getMessage(key, params = undefined) {
+    if (!params) {
+      params = this.getMessageParams();
+    }
+    return this._application.messagesBuilder.getMessage(key, params);
+  }
+  getMessageParams() {
+    //TODO: Atualmente ainda não usamos o recurso de multiseleção do dataunit, mas no futuro
+    //precisaremos criar um mecanismo para oferecer todos os registros selecionados para a 
+    //mensagem
+    return this.dataState.selectedRecords ? this.dataState.selectedRecords[0] : undefined;
+  }
+  getMessageOperation() {
+    if (this.dataState.copyMode) {
+      return OperationMap.CLONE;
+    }
+    if (this.dataState.insertionMode) {
+      return OperationMap.INSERT;
+    }
+    if (this.dataState.isDirty) {
+      return OperationMap.UPDATE;
+    }
+    return OperationMap.CLEAN;
+  }
+  async loadDataUnit() {
+    if (!this.dataUnit) {
+      if (this._application && this.entityName) {
+        const cacheName = this.dataUnitName ? this.dataUnitName : this.entityName;
+        this.dataUnit = await this._application.getDataUnit(this.entityName, cacheName);
+        this.dataUnit.pageSize = this.pageSize;
+        this.dataUnit.unsubscribe(this._dataUnitObserver);
+        this.dataUnit.addInterceptor(this);
+        this.dataUnit.subscribe(this._dataUnitObserver);
+        let resolver;
+        while (resolver = this._onDataUnitResolve.pop()) {
+          resolver(this.dataUnit);
+        }
+        if (this.autoLoad) {
+          setTimeout(() => {
+            this.dataUnit.loadData();
+          }, 500); //TODO: Ajustar para aguardar filterProvider do dataunit estar pronto.
+        }
+      }
+    }
+  }
+  //---------------------------------------------
+  // Lifecycle web component
+  //---------------------------------------------
+  componentWillLoad() {
+    this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    this._application.getAllAccess().then(access => this._permissions = access);
+  }
+  componentDidLoad() {
+    this.loadDataUnit();
+  }
+  render() {
+    return (h(Host, null));
+  }
+  static get is() { return "snk-data-unit"; }
+  static get encapsulation() { return "scoped"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["snk-data-unit.css"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["snk-data-unit.css"]
+    };
+  }
+  static get properties() {
+    return {
+      "dataState": {
+        "type": "unknown",
+        "mutable": true,
+        "complexType": {
+          "original": "DataState",
+          "resolved": "DataState",
+          "references": {
+            "DataState": {
+              "location": "local"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "O estato atual dos dados, isto \u00E9 se h\u00E1 altera\u00E7\u00E3o, insers\u00E3o, as linhas selecionadas, etc."
+        }
+      },
+      "dataUnitName": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Este atributo \u00E9 usado para criar o dataUnit uma \u00FAnica vez. Se omitido ser\u00E1 usado o pr\u00F3prio nome\nda entidade."
+        },
+        "attribute": "data-unit-name",
+        "reflect": false
+      },
+      "entityName": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Determina qual a entidade representa os dados em quest\u00E3o."
+        },
+        "attribute": "entity-name",
+        "reflect": false
+      },
+      "pageSize": {
+        "type": "number",
+        "mutable": false,
+        "complexType": {
+          "original": "number",
+          "resolved": "number",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Determina quantas linhas s\u00E3o retornadas por p\u00E1gina"
+        },
+        "attribute": "page-size",
+        "reflect": false,
+        "defaultValue": "150"
+      },
+      "dataUnit": {
+        "type": "unknown",
+        "mutable": true,
+        "complexType": {
+          "original": "DataUnit",
+          "resolved": "DataUnit",
+          "references": {
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Uma vez instanciado, pode-se obter o dataUnit por esta propriedade"
+        }
+      },
+      "beforeSave": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "(dataUnit: DataUnit) => boolean | Promise<boolean>",
+          "resolved": "(dataUnit: DataUnit) => boolean | Promise<boolean>",
+          "references": {
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            },
+            "Promise": {
+              "location": "global"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Executado imediatamente antes da a\u00E7\u00E3o de salvar as altera\u00E7\u00F5es. \u00DAtil no caso de valida\u00E7\u00F5es por exemplo.\nCaso retorne \"false\" (ou a promessa se resolva como false), cancela a a\u00E7\u00E3o."
+        }
+      },
+      "afterSave": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "(dataUnit: DataUnit) => void",
+          "resolved": "(dataUnit: DataUnit) => void",
+          "references": {
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Executado ap\u00F3s a a\u00E7\u00E3o de salvar"
+        }
+      },
+      "autoLoad": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Quando ativada essa propriedade faz com que haja uma carga imediata no DataUnit"
+        },
+        "attribute": "auto-load",
+        "reflect": false,
+        "defaultValue": "true"
+      }
+    };
+  }
+  static get events() {
+    return [{
+        "method": "dataStateChange",
+        "name": "dataStateChange",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Disparado quando o h\u00E1 qualquer mudan\u00E7a de estado no DataUnit"
+        },
+        "complexType": {
+          "original": "DataState",
+          "resolved": "DataState",
+          "references": {
+            "DataState": {
+              "location": "local"
+            }
+          }
+        }
+      }, {
+        "method": "dataUnitReady",
+        "name": "dataUnitReady",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Disparado quando o DataUnit est\u00E1 pronto"
+        },
+        "complexType": {
+          "original": "DataUnit",
+          "resolved": "DataUnit",
+          "references": {
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            }
+          }
+        }
+      }, {
+        "method": "insertionMode",
+        "name": "insertionMode",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Disparado quando um registro \u00E9 adicionado ou copiado"
+        },
+        "complexType": {
+          "original": "void",
+          "resolved": "void",
+          "references": {}
+        }
+      }, {
+        "method": "cancelEdition",
+        "name": "cancelEdition",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": "Disparado quando se cancela uma insers\u00E3o/c\u00F3pia"
+        },
+        "complexType": {
+          "original": "void",
+          "resolved": "void",
+          "references": {}
+        }
+      }];
+  }
+  static get methods() {
+    return {
+      "getDataUnit": {
+        "complexType": {
+          "signature": "() => Promise<DataUnit>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            },
+            "DataUnit": {
+              "location": "import",
+              "path": "@sankhyalabs/core"
+            }
+          },
+          "return": "Promise<DataUnit>"
+        },
+        "docs": {
+          "text": "Pode-se obter o dataUnit atrav\u00E9s desse m\u00E9todo. Outra forma, \u00E9 ouvir o evento de",
+          "tags": [{
+              "name": "returns",
+              "text": "dataUnit"
+            }]
+        }
+      }
+    };
+  }
+  static get elementRef() { return "element"; }
+  static get watchers() {
+    return [{
+        "propName": "pageSize",
+        "methodName": "observePageSize"
+      }, {
+        "propName": "dataUnitName",
+        "methodName": "observeDataUnitName"
+      }, {
+        "propName": "entityName",
+        "methodName": "observeEntityName"
+      }, {
+        "propName": "dataState",
+        "methodName": "observeDataState"
+      }, {
+        "propName": "dataUnit",
+        "methodName": "observeDataUnit"
+      }];
+  }
+}

package/dist/collection/components/snk-filter-bar/filter-item/editors/snk-filter-binary-select.js

@@ -0,0 +1,88 @@
+import { h, Host } from '@stencil/core';
+import FilterItemType from '../filter-item-type.enum';
+export class SnkFilterBinarySelect {
+  isSelected(option) {
+    return this.value == undefined || this.value === option;
+  }
+  ezChangeListener(evt) {
+    if (!evt.detail) {
+      this.assertCheckedOption(evt.target);
+    }
+    this.updateValue();
+  }
+  assertCheckedOption(updatingCheck) {
+    if (updatingCheck === this._checkOne) {
+      this._checkTwo.value = true;
+    }
+    else {
+      this._checkOne.value = true;
+    }
+  }
+  updateValue() {
+    if (!this._checkOne.value || !this._checkTwo.value) {
+      const [optOne, optTwo] = this.config.props.options;
+      this.value = this._checkOne.value ? optOne.name : optTwo.name;
+    }
+    else {
+      this.value = undefined;
+    }
+  }
+  render() {
+    if (!this.config || this.config.type !== FilterItemType.BINARY_SELECT) {
+      return undefined;
+    }
+    const [optOne, optTwo] = this.config.props.options;
+    return (h(Host, null, h("ez-check", { label: optOne.label, class: "sc-snk-filter-bar editor__ez-check", ref: (ref) => this._checkOne = ref, value: this.isSelected(optOne.name) }), h("ez-check", { label: optTwo.label, class: "sc-snk-filter-bar editor__ez-check", ref: (ref) => this._checkTwo = ref, value: this.isSelected(optTwo.name) })));
+  }
+  static get is() { return "snk-filter-binary-select"; }
+  static get properties() {
+    return {
+      "value": {
+        "type": "any",
+        "mutable": true,
+        "complexType": {
+          "original": "any",
+          "resolved": "any",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "attribute": "value",
+        "reflect": true
+      },
+      "config": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "SnkFilterItemConfig",
+          "resolved": "SnkFilterItemConfig",
+          "references": {
+            "SnkFilterItemConfig": {
+              "location": "import",
+              "path": "../snk-filter-item"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": ""
+        }
+      }
+    };
+  }
+  static get listeners() {
+    return [{
+        "name": "ezChange",
+        "method": "ezChangeListener",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }];
+  }
+}

package/dist/collection/components/snk-filter-bar/filter-item/editors/snk-filter-multi-select.js

@@ -0,0 +1,64 @@
+import { h } from '@stencil/core';
+import FilterItemType from '../filter-item-type.enum';
+export class SnkFilterMultiSelect {
+  ezChangeListener(evt) {
+    this.value = evt.detail.value;
+  }
+  render() {
+    if (!this.config || this.config.type !== FilterItemType.MULTI_SELECT) {
+      return undefined;
+    }
+    return (h("ez-combo-box", { label: this.config.label, value: this.config.value, options: this.config.props.options }));
+  }
+  static get is() { return "snk-filter-multi-select"; }
+  static get properties() {
+    return {
+      "value": {
+        "type": "any",
+        "mutable": true,
+        "complexType": {
+          "original": "any",
+          "resolved": "any",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "attribute": "value",
+        "reflect": true
+      },
+      "config": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "SnkFilterItemConfig",
+          "resolved": "SnkFilterItemConfig",
+          "references": {
+            "SnkFilterItemConfig": {
+              "location": "import",
+              "path": "../snk-filter-item"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": ""
+        }
+      }
+    };
+  }
+  static get listeners() {
+    return [{
+        "name": "ezChange",
+        "method": "ezChangeListener",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }];
+  }
+}