@sankhyalabs/sankhyablocks 1.3.31-beta.1 → 1.3.31-beta.11

package/dist/collection/components/snk-crud/snk-crud.js

@@ -0,0 +1,137 @@
+import { Component, h, Prop, Element, State } from '@stencil/core';
+const GRID_MODE = 0;
+const FORM_MODE = 1;
+/**
+ * É 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 os arquivos neste projeto "/src/lib/message/resources/*.msg.ts"
+ */
+export class SnkCrud {
+  async gridToForm(keepFormMode = false) {
+    this._backToGrid = !keepFormMode && await this._viewStack.getSelectedIndex() === GRID_MODE;
+    this._viewStack.show(FORM_MODE);
+  }
+  async executeAction(act) {
+    if (act === "GRID_MODE") {
+      this._viewStack.show(GRID_MODE);
+    }
+    else if (act === "FORM_MODE" || act === "UPDATE") {
+      this.gridToForm(act !== "UPDATE");
+    }
+  }
+  insertionModeHandler() {
+    this.gridToForm();
+  }
+  cancelHandler() {
+    if (this._backToGrid) {
+      this._viewStack.show(GRID_MODE);
+    }
+  }
+  componentWillLoad() {
+    let parent = this._element.parentElement;
+    while (parent) {
+      if (parent.tagName.toUpperCase() === "SNK-DATA-UNIT") {
+        this._snkDataUnit = parent;
+        this._snkDataUnit.addEventListener("insertionMode", () => this.insertionModeHandler());
+        this._snkDataUnit.addEventListener("cancelEdition", () => this.cancelHandler());
+        this._dataUnit = this._snkDataUnit.dataUnit;
+        this._dataState = this._snkDataUnit.dataState;
+        if (!this._dataUnit) {
+          this._snkDataUnit.addEventListener("dataUnitReady", (evt) => {
+            this._dataUnit = evt.detail;
+          });
+        }
+        this._snkDataUnit.addEventListener("dataStateChange", (evt) => {
+          this._dataState = evt.detail;
+        });
+        break;
+      }
+      parent = parent.parentElement;
+    }
+  }
+  render() {
+    return (h("ez-view-stack", { ref: (ref) => this._viewStack = ref },
+      h("stack-item", null,
+        h("snk-grid", { configName: this.configName, onGridDoubleClick: () => this.gridToForm(true), onActionClick: evt => this.executeAction(evt.detail), actionsList: this.actionsList },
+          h("slot", null))),
+      h("stack-item", null,
+        h("snk-form", { configName: this.configName, actionsList: this.actionsList, onExit: () => this._viewStack.show(GRID_MODE), recordsValidator: this.recordsValidator, onActionClick: evt => this.executeAction(evt.detail) }))));
+  }
+  static get is() { return "snk-crud"; }
+  static get encapsulation() { return "scoped"; }
+  static get originalStyleUrls() { return {
+    "$": ["snk-crud.css"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["snk-crud.css"]
+  }; }
+  static get properties() { return {
+    "configName": {
+      "type": "string",
+      "mutable": false,
+      "complexType": {
+        "original": "string",
+        "resolved": "string",
+        "references": {}
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      },
+      "attribute": "config-name",
+      "reflect": false
+    },
+    "actionsList": {
+      "type": "unknown",
+      "mutable": false,
+      "complexType": {
+        "original": "Array<Action>",
+        "resolved": "Action[]",
+        "references": {
+          "Array": {
+            "location": "global"
+          },
+          "Action": {
+            "location": "import",
+            "path": "../snk-taskbar/snk-taskbar"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": ""
+      }
+    },
+    "recordsValidator": {
+      "type": "any",
+      "mutable": false,
+      "complexType": {
+        "original": "RecordValidator",
+        "resolved": "RecordValidator",
+        "references": {
+          "RecordValidator": {
+            "location": "import",
+            "path": "@sankhyalabs/ezui/dist/types/components/ez-form/ez-form"
+          }
+        }
+      },
+      "required": false,
+      "optional": false,
+      "docs": {
+        "tags": [],
+        "text": "Validador respons\u00E1vel por checar a integridade das informa\u00E7\u00F5es do registro"
+      },
+      "attribute": "records-validator",
+      "reflect": false
+    }
+  }; }
+  static get states() { return {
+    "_dataUnit": {},
+    "_dataState": {}
+  }; }
+  static get elementRef() { return "_element"; }
+}

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

@@ -0,0 +1,6 @@
+:host {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+  }
+  

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

@@ -0,0 +1,528 @@
+import { Component, Host, h, Event, Element, Prop, Watch, Method } from '@stencil/core';
+import { Action, ApplicationContext } from '@sankhyalabs/core';
+import { ApplicationUtils } 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.info(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", true, { 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) {
+          this.dataUnit.loadData();
+        }
+      }
+    }
+  }
+  //---------------------------------------------
+  // Lifecycle web component
+  //---------------------------------------------
+  componentWillLoad() {
+    this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    this._application.getAllAccess().then(access => this._permissions = access);
+    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-form/snk-form.css

@@ -0,0 +1,34 @@
+:host {
+  display: block;
+}
+
+.snk-form {
+  position: relative;
+
+  /*public*/
+  padding: var(--space--large);
+  padding-top: var(--space--medium);
+}
+
+.snk-form__header {
+  position: relative;
+
+  /*public*/
+  padding-top: var(--space--medium);
+  padding-bottom: var(--space--medium);
+  margin-bottom: var(--space--medium);
+}
+
+.snk-form__header--fixed {
+  position: sticky;
+  top: 0;
+
+  /*public*/
+  background: var(--background--body);
+  z-index: var(--more-visible, 2);
+  padding-left: var(--space--large);
+  padding-right: var(--space--large);
+  margin-left: calc(var(--space--large) * -1);
+  margin-right: calc(var(--space--large) * -1);
+  width: calc(100% + (var(--space--large) * 2));
+}