@sankhyalabs/sankhyablocks 0.0.0-feat-dev-kb-4158.0

package/dist/collection/components/snk-actions-button/snk-actions-button.js

@@ -0,0 +1,139 @@
+import { h, Host } from '@stencil/core';
+import { ApplicationContext, ArrayUtils, ElementIDUtils } from '@sankhyalabs/core';
+import { DataFetcher } from '../../lib/http/data-fetcher/DataFetcher';
+import ExecutorFactory from './actions/factory/executor.factory';
+import Actions from './actions';
+import ClientEventConfirm from './clientEvent';
+export class SnkActionsButton {
+  constructor() {
+    this.CLIENT_EVENT_CONFIRM_NAME = "br.com.sankhya.actionbutton.clientconfirm";
+    this.handleClick = (evt) => {
+      const selectedAction = this._actions.find((action) => action.actionID == evt.detail.id);
+      const executor = new ExecutorFactory(selectedAction.type).executor;
+      const action = new Actions(executor, this._dataUnit);
+      action.execute(Object.assign({}, selectedAction));
+      this._showDropdown = false;
+    };
+    this._items = [];
+    this._showDropdown = false;
+    this._actions = [];
+    this._isOrderActions = false;
+  }
+  async getActions() {
+    let param = {
+      param: {
+        entityName: this._entityName,
+        resourceID: this._resourceID
+      }
+    };
+    return DataFetcher.get().callServiceBroker('ActionButtonsSP.getActions', param).then((result) => {
+      var _a;
+      if (!((_a = result.actions) === null || _a === void 0 ? void 0 : _a.action))
+        return;
+      if (this._isOrderActions) {
+        this._actions = ArrayUtils.sortAlphabetically(result.actions.action, 'description');
+      }
+      else {
+        this._actions = result.actions.action;
+      }
+    });
+  }
+  controlDropdown() {
+    this._showDropdown = !this._showDropdown;
+  }
+  canShowDropdown() {
+    var _a;
+    return this._showDropdown && ((_a = this._items) === null || _a === void 0 ? void 0 : _a.length) > 0;
+  }
+  positionDropdown() {
+    var _a;
+    const bounding = (_a = this._ezButton) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
+    if (!bounding || !this._dropdownParent)
+      return;
+    this._dropdownParent.style.top = (bounding.y + bounding.height + 5) + "px";
+    this._dropdownParent.style.left = bounding.x + "px";
+  }
+  closeDropdown(evt) {
+    const target = evt === null || evt === void 0 ? void 0 : evt.target;
+    if (!target)
+      return;
+    if (!target.closest(".snk-actions-button")) {
+      this._showDropdown = false;
+    }
+  }
+  setEvents() {
+    document.removeEventListener("click", this.closeDropdown.bind(this));
+    document.addEventListener("click", this.closeDropdown.bind(this));
+    document.removeEventListener("scroll", this.positionDropdown.bind(this));
+    document.addEventListener("scroll", this.positionDropdown.bind(this));
+  }
+  async componentWillLoad() {
+    var _a;
+    this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    this._resourceID = await this._application.getResourceID();
+    this._isOrderActions = await this._application.getBooleanParam('global.ordenar.acoes.personalizadas');
+    this._dataUnit = (_a = this._element.parentElement) === null || _a === void 0 ? void 0 : _a.dataUnit;
+    this._entityName = this._dataUnit.name.split('/')[2];
+    this.setEvents();
+    this.getActions().then(() => {
+      this.loadItems();
+    });
+  }
+  async componentDidLoad() {
+    if (!this._element)
+      return;
+    ElementIDUtils.addIDInfo(this._element);
+    this.positionDropdown();
+    if (!(await this._application.hasClientEvent(this.CLIENT_EVENT_CONFIRM_NAME))) {
+      const clientEventConfirm = new ClientEventConfirm();
+      this._application.addClientEvent(this.CLIENT_EVENT_CONFIRM_NAME, clientEventConfirm.clientConfirm);
+    }
+  }
+  componentDidUpdate() {
+    this.positionDropdown();
+  }
+  loadItems() {
+    if (!this._actions || this._actions.length == 0)
+      return;
+    this._actions.forEach(action => {
+      this._items.push({ id: action.actionID, label: action.description });
+    });
+  }
+  getElementID(sufix) {
+    return {
+      [ElementIDUtils.DATA_ELEMENT_ID_ATTRIBUTE_NAME]: ElementIDUtils.getInternalIDInfo(sufix)
+    };
+  }
+  render() {
+    return (h(Host, null, (this._actions && this._actions.length > 0) &&
+      (h("div", { class: `ez-padding-left--medium snk-actions-button 
+                            ${this.canShowDropdown() ? " snk-actions-button--overlap" : ""}
+                        ` }, h("ez-button", Object.assign({ ref: (ref) => this._ezButton = ref, iconName: "acao", size: "small", mode: "icon", title: this._application.messagesBuilder.getMessage("snkActionsButton.title.actions", undefined), onClick: () => this.controlDropdown() }, this.getElementID("button"))), h("div", Object.assign({ ref: (ref) => this._dropdownParent = ref, class: `${this.canShowDropdown() ?
+          "snk-actions-button__dropdown--show" :
+          "snk-actions-button__dropdown"}
+                            ` }, this.getElementID("dropdown")), (this.canShowDropdown()) &&
+        (h("ez-dropdown", Object.assign({ items: this._items, onEzClick: (evt) => this.handleClick(evt) }, this.getElementID("dropdown"))))))), (this.canShowDropdown()) &&
+      (h("div", Object.assign({ class: "ez-scrim ez-scrim--light" }, this.getElementID("ezScrim"))))));
+  }
+  static get is() { return "snk-actions-button"; }
+  static get encapsulation() { return "scoped"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["snk-actions-button.css"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["snk-actions-button.css"]
+    };
+  }
+  static get states() {
+    return {
+      "_items": {},
+      "_showDropdown": {},
+      "_actions": {},
+      "_isOrderActions": {}
+    };
+  }
+  static get elementRef() { return "_element"; }
+}

package/dist/collection/components/snk-actions-button/subcomponents/snk-actions-form.js

@@ -0,0 +1,263 @@
+import { ApplicationContext, DataType, DataUnit, UserInterface } from '@sankhyalabs/core';
+import { h } from '@stencil/core';
+import { ParamType } from '../actions/enum/ParamType';
+export class SnkActionsForm {
+  constructor() {
+    this.APPLY = 'OK';
+    this.CANCEL = 'CANCEL';
+    this.CLOSE = 'CLOSE';
+    this.action = undefined;
+    this.applyParameters = undefined;
+    this.dataUnit = new DataUnit();
+  }
+  /**
+   * Responsável por abrir a popup.
+   */
+  async openPopup() {
+    this._ezPopup.opened = true;
+  }
+  ;
+  exitPopup() {
+    this._ezPopup.opened = false;
+  }
+  async handleApply() {
+    try {
+      await this._ezForm.validate();
+      let row = this.dataUnit.getSelectedRecord();
+      if (row) {
+        this._params.forEach((param, index) => {
+          if (row.hasOwnProperty(param.name)) {
+            if (param.paramType == ParamType.ENTITY) {
+              let searchValue = row[param.name];
+              if (!searchValue) {
+                param.value = null;
+                return;
+              }
+              param.value = typeof searchValue === 'object' ? searchValue.value : searchValue;
+              return;
+            }
+            this._params[index].value = row[param.name];
+          }
+          else {
+            this._params[index].value = undefined;
+          }
+        });
+        this.action.actionConfig.params.promptParam = this._params;
+      }
+      this.exitPopup();
+      this.applyParameters(this.action);
+    }
+    catch (e) {
+      // exceção ignorada, quando o validate() falha.
+    }
+  }
+  searchLoader(evt, param) {
+    const options = {
+      entity: param.entityName,
+      entityDescription: param.label
+    };
+    return this._application.executePreparedSearch(evt.mode, evt.argument, options);
+  }
+  ;
+  getUserInterface(paramType) {
+    switch (paramType) {
+      case ParamType.TEXT:
+        return UserInterface.SHORTTEXT;
+      case ParamType.INTEGER:
+        return UserInterface.INTEGERNUMBER;
+      case ParamType.DECIMAL:
+        return UserInterface.DECIMALNUMBER;
+      case ParamType.DATE:
+        return UserInterface.DATE;
+      case ParamType.DATETIME:
+        return UserInterface.DATETIME;
+      case ParamType.BOOLEAN:
+        return UserInterface.CHECKBOX;
+      case ParamType.ENTITY:
+        return UserInterface.SEARCH;
+      case ParamType.OPTIONS:
+        return UserInterface.OPTIONSELECTOR;
+    }
+  }
+  getDataType(paramType) {
+    switch (paramType) {
+      case ParamType.TEXT:
+      case ParamType.OPTIONS:
+        return DataType.TEXT;
+      case ParamType.INTEGER:
+      case ParamType.DECIMAL:
+        return DataType.NUMBER;
+      case ParamType.DATE:
+      case ParamType.DATETIME:
+        return DataType.DATE;
+      case ParamType.BOOLEAN:
+        return DataType.BOOLEAN;
+      case ParamType.ENTITY:
+        return DataType.OBJECT;
+    }
+  }
+  getProps(param) {
+    switch (param.paramType) {
+      case ParamType.DECIMAL:
+        return param.precision ? { precision: Number(param.precision) } : undefined;
+      case ParamType.ENTITY:
+        return { ENTITYNAME: param.entityName };
+      case ParamType.OPTIONS:
+        return { options: this.prepareOptions(param.options) };
+      default:
+        return undefined;
+    }
+  }
+  buildFields() {
+    let fields = [];
+    this._params.forEach((param, index) => {
+      const hasName = !!param.name;
+      let paramName = hasName ? param.name : `param_${index}`;
+      fields.push({
+        name: paramName,
+        label: param.label,
+        dataType: this.getDataType(param.paramType),
+        userInterface: this.getUserInterface(param.paramType),
+        readOnly: false,
+        required: param.paramType == 'B' ? false : param.required === "true",
+        properties: this.getProps(param)
+      });
+      this._params[index].name = paramName;
+      this._params[index].isGeneratedName = !hasName;
+    });
+    const metadata = {
+      name: 'params',
+      label: 'params',
+      fields: fields
+    };
+    this._metadata = metadata;
+  }
+  fillFields() {
+    this._params.forEach((param) => {
+      if (param.saveLast == 'true') {
+        this.dataUnit.setFieldValue(param.name, param.value);
+      }
+    });
+  }
+  prepareOptions(options) {
+    const optionsArray = options.split(";");
+    let optionsList = optionsArray.map(function (opc, index) {
+      let value;
+      let label;
+      if (opc.indexOf('=') > -1) {
+        let opcArr = opc.split('=');
+        value = opcArr[0];
+        label = opcArr[1];
+      }
+      else {
+        value = (index + 1).toString();
+        label = opc;
+      }
+      return {
+        value: value,
+        label: label
+      };
+    });
+    return optionsList;
+  }
+  componentWillLoad() {
+    this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    this._params = [...this.action.actionConfig.params.promptParam];
+    this.dataUnit.metadataLoader = this.metadataLoader.bind(this);
+    this.dataUnit.loadMetadata().then(() => {
+      this.fillFields();
+    });
+    this.dataUnit.addRecord();
+  }
+  async metadataLoader() {
+    return new Promise((resolve) => {
+      this.buildFields();
+      resolve(this._metadata);
+    });
+  }
+  handleModalAction(evt) {
+    switch (evt) {
+      case this.APPLY:
+        this.handleApply();
+        break;
+      case this.CANCEL:
+      case this.CLOSE:
+        this.exitPopup();
+        break;
+    }
+  }
+  render() {
+    return (h("ez-popup", { size: "medium", heightMode: "auto", useHeader: false, ref: (ref) => this._ezPopup = ref }, h("ez-modal-container", { modalTitle: this._application.messagesBuilder.getMessage("snkActionsButton.form.fillParams", undefined), okButtonLabel: this._application.messagesBuilder.getMessage("snkActionsButton.buttons.apply", undefined), cancelButtonLabel: this._application.messagesBuilder.getMessage("snkActionsButton.buttons.cancel", undefined), onEzModalAction: (evt) => this.handleModalAction(evt.detail) }, h("div", { class: "ez-margin-vertical--medium" }, h("ez-form", { ref: (ref) => this._ezForm = ref, dataUnit: this.dataUnit })))));
+  }
+  static get is() { return "snk-actions-form"; }
+  static get encapsulation() { return "scoped"; }
+  static get properties() {
+    return {
+      "action": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "IAction",
+          "resolved": "IAction",
+          "references": {
+            "IAction": {
+              "location": "import",
+              "path": "../actions/interfaces/IAction"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "A\u00E7\u00E3o na qual os par\u00E2metros ser\u00E3o preenchidos."
+        }
+      },
+      "applyParameters": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "(action: IAction) => void",
+          "resolved": "(action: IAction) => void",
+          "references": {
+            "IAction": {
+              "location": "import",
+              "path": "../actions/interfaces/IAction"
+            }
+          }
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Respons\u00E1vel por retornar a a\u00E7\u00E3o com os par\u00E2metros preenchidos."
+        }
+      }
+    };
+  }
+  static get states() {
+    return {
+      "dataUnit": {}
+    };
+  }
+  static get methods() {
+    return {
+      "openPopup": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Respons\u00E1vel por abrir a popup.",
+          "tags": []
+        }
+      }
+    };
+  }
+}

package/dist/collection/components/snk-actions-button/subcomponents/snk-client-confirm.js

@@ -0,0 +1,134 @@
+import { ApplicationContext } from '@sankhyalabs/core';
+import { h } from '@stencil/core';
+export class SnkActionsForm {
+  constructor() {
+    this.APLICAR = 'OK';
+    this.CANCELAR = 'CANCEL';
+    this.FECHAR = 'CLOSE';
+    this.titleMessage = undefined;
+    this.message = undefined;
+    this.accept = undefined;
+    this.cancel = undefined;
+  }
+  /**
+   * Responsável por abrir a popup.
+   */
+  async openPopup() {
+    this._ezPopup.opened = true;
+  }
+  ;
+  exitPopup() {
+    this._ezPopup.opened = false;
+  }
+  handleModalAction(evt) {
+    switch (evt) {
+      case this.APLICAR:
+        this.exitPopup();
+        this.accept();
+        break;
+      case this.CANCELAR:
+        this.exitPopup();
+        this.cancel();
+        break;
+      case this.FECHAR:
+        this.exitPopup();
+        break;
+    }
+  }
+  componentWillLoad() {
+    this._application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+  }
+  render() {
+    return (h("ez-popup", { size: "small", heightMode: "auto", useHeader: false, ref: (ref) => this._ezPopup = ref }, h("ez-modal-container", { modalTitle: this.titleMessage, okButtonLabel: this._application.messagesBuilder.getMessage("snkActionsButton.buttons.yes", undefined), cancelButtonLabel: this._application.messagesBuilder.getMessage("snkActionsButton.buttons.no", undefined), onEzModalAction: (evt) => this.handleModalAction(evt.detail) }, h("div", { class: "ez-margin-bottom--large ez-flex ez-flex--column" }, h("label", { class: "ez-text ez-text--large ez-text--primary", innerHTML: this.message }), h("label", { class: "ez-text ez-text--large ez-text--primary" }, h("br", null), this._application.messagesBuilder.getMessage("snkActionsButton.clientEvent.cancelMessage", undefined))))));
+  }
+  static get is() { return "snk-client-confirm"; }
+  static get encapsulation() { return "scoped"; }
+  static get properties() {
+    return {
+      "titleMessage": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "T\u00EDtulo da popup."
+        },
+        "attribute": "title-message",
+        "reflect": false
+      },
+      "message": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Mensagem da popup."
+        },
+        "attribute": "message",
+        "reflect": false
+      },
+      "accept": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "() => void",
+          "resolved": "() => void",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Retorno quando usu\u00E1rio confirmar."
+        }
+      },
+      "cancel": {
+        "type": "unknown",
+        "mutable": false,
+        "complexType": {
+          "original": "() => void",
+          "resolved": "() => void",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": "Retorno quando usu\u00E1rio cancelar."
+        }
+      }
+    };
+  }
+  static get methods() {
+    return {
+      "openPopup": {
+        "complexType": {
+          "signature": "() => Promise<void>",
+          "parameters": [],
+          "references": {
+            "Promise": {
+              "location": "global"
+            }
+          },
+          "return": "Promise<void>"
+        },
+        "docs": {
+          "text": "Respons\u00E1vel por abrir a popup.",
+          "tags": []
+        }
+      }
+    };
+  }
+}

package/dist/collection/components/snk-application/errorhandler/snk-error-handler.js

@@ -0,0 +1,60 @@
+import { WarningException, WaitingChangeException, ErrorException, ObjectUtils } from "@sankhyalabs/core";
+export class SnkErrorHandler {
+  constructor(app) {
+    this._app = app;
+    window.addEventListener("error", evt => this.errorHandler(evt));
+    window.addEventListener("unhandledrejection", evt => this.rejectionHandler(evt));
+  }
+  rejectionHandler(evt) {
+    const reason = evt.reason;
+    //Promisse rejeitada com WaitingChangeException, não precisam
+    //ser notificadas pelo usuário.
+    if (!(reason instanceof WaitingChangeException)) {
+      if (reason) {
+        this.processException(reason);
+      }
+      else {
+        this._app.isDebugMode().then((isDebug) => {
+          if (isDebug) {
+            this._app.error("Promise rejeitada", "Erro interno: Uma promise foi rejeitada sem razão determinada.");
+          }
+        });
+      }
+    }
+  }
+  errorHandler(evt) {
+    this.processException(evt.error);
+  }
+  buildErrorCodeHTML(errorCode) {
+    const onclick = 'try{window.workspace.openHelp(\'_tbcode:' + errorCode + '\')} catch(e){alert(\'Não é possível abrir a ajuda fora do workspace Sankhya\');}';
+    return '<br><a href="#" onclick="' + onclick + '">Código: ' + errorCode + '</a>';
+  }
+  processException(exception) {
+    if (exception.errorCode) {
+      exception.message += this.buildErrorCodeHTML(exception.errorCode);
+    }
+    if (exception instanceof WaitingChangeException) {
+      this._app.alert(exception.title, exception.message);
+    }
+    else if (exception instanceof WarningException) {
+      this._app.alert(exception.title, exception.message);
+    }
+    else if (exception instanceof ErrorException) {
+      this._app.error(exception.title, exception.message);
+    }
+    else {
+      this._app.isDebugMode().then(isDebug => {
+        if (isDebug) {
+          if (exception instanceof Error) {
+            this._app.error(exception.name, exception.message);
+          }
+          else {
+            const title = (exception === null || exception === void 0 ? void 0 : exception.title) || "Erro detectado";
+            const message = (typeof exception === "string") ? exception : exception.message || `Erro interno "${ObjectUtils.objectToString(exception)}"`;
+            this._app.error(title, message);
+          }
+        }
+      });
+    }
+  }
+}

package/dist/collection/components/snk-application/snk-application.css

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