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

package/dist/collection/lib/utils/PrintUtils.js

@@ -0,0 +1,201 @@
+import { StringUtils } from "@sankhyalabs/core";
+import { DataFetcher } from "../http/data-fetcher/DataFetcher";
+export class PrintUtils {
+  constructor() {
+    this.appletImpressao = new AppletImpressao();
+  }
+  static getInstance() {
+    if (!PrintUtils.instance) {
+      PrintUtils.instance = new PrintUtils();
+    }
+    return PrintUtils.instance;
+  }
+  async processPendingPrinting(transactionId) {
+    await this.findPendingPrints(transactionId);
+  }
+  async findPendingPrints(transactionId) {
+    const requestBody = {
+      transactionIds: [
+        {
+          transactionId: {
+            $: transactionId
+          }
+        }
+      ]
+    };
+    const response = await DataFetcher.get().callServiceBroker(PrintUtils.SERVICE_FIND_PENDING_PRINTS, JSON.stringify(requestBody));
+    const printJobData = this.parsePrintData(response);
+    const pendingPrints = await this.processDirectPrint(printJobData);
+    if (!pendingPrints.length)
+      return;
+    this.openSnkPrintSelector(Object.assign(Object.assign({}, printJobData), { pendingPrinters: pendingPrints }));
+  }
+  getLocalPrinters() {
+    const localPrinters = this.appletImpressao.findLocalPrinters();
+    const printers = [];
+    for (const printerName of localPrinters) {
+      printers.push({
+        nome: printerName,
+        printerUri: PrintUtils.LOCAL_SERVER_URI + printerName,
+        isLocal: true
+      });
+    }
+    return printers;
+  }
+  parsePrintData(payload) {
+    const pendingPrintJobData = payload.pendindPrintJobData;
+    if (!pendingPrintJobData)
+      return undefined;
+    let { printServers: { printServer }, pendingPrinters: { pendingPrinter } } = pendingPrintJobData;
+    printServer = printServer ? (Array.isArray(printServer) ? printServer : [printServer]) : [];
+    pendingPrinter = pendingPrinter ? (Array.isArray(pendingPrinter) ? pendingPrinter : [pendingPrinter]) : [];
+    const normalizedPrintServer = printServer.map(item => {
+      const printerList = Array.isArray(item.printerLocation) ? item.printerLocation : [item.printerLocation];
+      return {
+        printServerUri: item.printServerUri,
+        printerList: printerList.map(this.normalize)
+      };
+    });
+    const normalizedPendingPrinter = pendingPrinter.map(this.normalize);
+    return {
+      transactionId: pendingPrintJobData.transactionId.$,
+      printServers: normalizedPrintServer,
+      pendingPrinters: normalizedPendingPrinter,
+      printServerActive: pendingPrintJobData.printServers.printServerActive === 'true'
+    };
+  }
+  normalize(object) {
+    const normalizedObject = {};
+    Object.keys(object).forEach((key) => {
+      normalizedObject[key] = PrintUtils.ENCODED_PROPERTIES.includes(key) ? window.atob(object[key].$) : object[key].$;
+    });
+    return normalizedObject;
+  }
+  processLocalPrinting(localPrintings) {
+    const transactionIds = localPrintings.map((item) => item.transactionId);
+    this.appletImpressao.doLocalPrinting(transactionIds.join());
+  }
+  async openSnkPrintSelector(printJobData) {
+    let printSelector = document.querySelector('snk-print-selector');
+    if (!printSelector) {
+      printSelector = document.createElement('snk-print-selector');
+      printSelector.setAttribute('id', StringUtils.generateUUID());
+      window.document.body.appendChild(printSelector);
+    }
+    const { selectedPrinter, saveSubstitute } = await printSelector.openPrintSelector(printJobData);
+    if (!selectedPrinter)
+      return;
+    const params = {
+      transactionId: printJobData.transactionId,
+      pendingPrinters: printJobData.pendingPrinters,
+      printerUri: selectedPrinter.printerUri,
+      saveSubstitutePrinters: saveSubstitute
+    };
+    await this.saveSubstitutePrinter(params);
+  }
+  async saveSubstitutePrinter(params) {
+    const { transactionId, pendingPrinters, printerUri, saveSubstitutePrinters = false } = params;
+    const parsedPendingPrinters = pendingPrinters.map((item) => ({
+      printerUri: {
+        $: item.printerUri || printerUri
+      },
+      originalPrinterName: {
+        $: item.originalPrinterName
+      },
+      printJobCount: {
+        $: item.printJobCount
+      },
+      docType: {
+        $: item.docType
+      },
+      docTypeDescription: {
+        $: item.docTypeDescription
+      }
+    }));
+    const requestBody = {
+      substitutePrintersRequest: {
+        substitutePrinters: {
+          pendingPrinter: parsedPendingPrinters
+        },
+        saveSubstitutePrinters: {
+          $: saveSubstitutePrinters.toString()
+        },
+        transactionId: {
+          $: transactionId
+        }
+      }
+    };
+    await DataFetcher.get().callServiceBroker(PrintUtils.SERVICE_SAVE_SUBSTITUTE_PRINTER, JSON.stringify(requestBody));
+  }
+  async processDirectPrint(printJobData) {
+    const isWCRunning = this.appletImpressao.checkWebConnection();
+    if (!isWCRunning) {
+      return [];
+    }
+    const localPrinters = this.getLocalPrinters();
+    if (!localPrinters.length)
+      return [];
+    const directPendingPrints = [];
+    const pendingPrints = printJobData.pendingPrinters.filter(item => {
+      const defaultPrinterName = this.getDefaultPrinterName(item.originalPrinterName);
+      const isDirectPrint = !!localPrinters.find(localPrinter => localPrinter.nome === defaultPrinterName) || this.isPrinterNameAFile(defaultPrinterName);
+      if (isDirectPrint) {
+        directPendingPrints.push(Object.assign(Object.assign({}, item), { printerUri: PrintUtils.LOCAL_SERVER_URI + defaultPrinterName }));
+        return false;
+      }
+      return true;
+    });
+    if (!directPendingPrints.length)
+      return pendingPrints;
+    const params = {
+      transactionId: printJobData.transactionId,
+      pendingPrinters: directPendingPrints
+    };
+    await this.saveSubstitutePrinter(params);
+    return pendingPrints;
+  }
+  getDefaultPrinterName(printerName) {
+    const defaultPrinterName = this.appletImpressao.getDefaultPrinter();
+    const isDefaultPrinterName = /padr[aã]o/ig.test(printerName);
+    return (defaultPrinterName && isDefaultPrinterName) ? defaultPrinterName : printerName;
+  }
+  isPrinterNameAFile(printerName) {
+    const regExp = new RegExp("^(\w:)?[/\\\w\s]+?\.\w{3}$", "mis");
+    return regExp.test(printerName);
+  }
+}
+PrintUtils.SERVICE_FIND_PENDING_PRINTS = 'mge@PrintServiceSP.findPendingPrinters';
+PrintUtils.SERVICE_SAVE_SUBSTITUTE_PRINTER = 'mge@PrintServiceSP.saveSubstitutePrinter';
+PrintUtils.LOCAL_SERVER_URI = 'LOCAL:0/';
+PrintUtils.ENCODED_PROPERTIES = ['printerName', 'printerUri'];
+class AppletImpressao {
+  constructor() {
+    this.appletImpressao = document.getElementById('centralNotaAppletImpressao');
+  }
+  checkWebConnection() {
+    if (!this.appletImpressao)
+      return false;
+    if (!this.appletImpressao.testRunningWC)
+      return false;
+    const isRunning = this.appletImpressao.testRunningWC();
+    return !!isRunning;
+  }
+  findLocalPrinters() {
+    if (!this.appletImpressao)
+      return [];
+    const localPrinters = this.appletImpressao.getLocalPrinters();
+    if (!localPrinters)
+      return [];
+    return localPrinters.split(",");
+  }
+  doLocalPrinting(transactionIds) {
+    if (!this.appletImpressao)
+      return;
+    this.appletImpressao.doLocalPrinting(transactionIds);
+  }
+  getDefaultPrinter() {
+    if (!this.appletImpressao)
+      return '';
+    return this.appletImpressao.getPrintDefault();
+  }
+}

package/dist/collection/lib/utils/constants.js

@@ -0,0 +1,102 @@
+export const REPORT_LAUNCHER_RESOURCE_ID = "br.com.sankhya.controls.ReportLauncher";
+export const KEY_PORT_EXPORT = "global.porta.app.impressao";
+export const ALL_RECORD = "ALL_RECORD";
+export var VIEW_MODE;
+(function (VIEW_MODE) {
+  VIEW_MODE[VIEW_MODE["GRID"] = 0] = "GRID";
+  VIEW_MODE[VIEW_MODE["FORM"] = 1] = "FORM";
+  VIEW_MODE[VIEW_MODE["ATTACHMENT"] = 2] = "ATTACHMENT";
+})(VIEW_MODE || (VIEW_MODE = {}));
+;
+export const ACTION_CONFIG = {
+  add: 'ADD',
+  remove: 'REMOVE',
+  configuration: 'CONFIGURATION'
+};
+export const VARS_BY_TYPE = {
+  UserInterface: {
+    DATE: [{ label: "Data atual", value: "${data}" }],
+    DATETIME: [{ label: "Data e hora atuais", value: "${datahora}" }],
+    INTEGERNUMBER: [
+      { label: "Código do usuário logado", value: "${usuario}" },
+      { label: "Empresa do usuário logado", value: "${usuario.empresa}" },
+      { label: "Vendedor para o usuário logado", value: "${usuario.vendedor}" },
+      { label: "Cent. Resultado usuário logado", value: "${usuario.centroresultado}" }
+    ]
+  }
+};
+export const DEFAULT_TYPE = {
+  fixed: "F",
+  variable: "V"
+};
+export const CONFIG_EVENTS = {
+  closeModal: "ezCloseModal",
+  cancelConfig: "cancelConfig",
+  changeConfig: "changeConfig",
+  configChanged: "configChanged",
+  fieldChanged: "ezChange",
+  dragStart: "sortable:start",
+  dragSort: "sortable:sort",
+  dragSorted: "sortable:sorted",
+  dragStop: "sortable:stop"
+};
+export const KEY_EVENTS = {
+  enter: "Enter",
+  arrowLeft: "ArrowLeft",
+  arrowRight: "ArrowRight",
+  tab: "Tab",
+  escape: "Escape"
+};
+export const TYPE_ACTIONS = {
+  rename: "RENAME",
+  hide: "HIDE",
+  show: "SHOW",
+  delete: "DELETE"
+};
+export const TAB_NAMES = {
+  main: "__main"
+};
+export const TAGS_BY_TYPE = {
+  LONGTEXT: "ez-text-area",
+  FILE: "ez-upload",
+  DATE: "ez-date-input",
+  TIME: "ez-time",
+  DATETIME: "ez-date-time-input",
+  DEFAULT: "ez-text-input",
+  SWITCH: "ez-check",
+  CHECKBOX: "ez-check",
+  OPTIONSELECTOR: "ez-combo-box",
+  SEARCH: "ez-search",
+  INTEGERNUMBER: "ez-number-input",
+  DECIMALNUMBER: "ez-number-input"
+};
+export const ORDER_VALUES = {
+  none: {
+    value: "NA",
+    label: "N/A",
+  },
+  asc: {
+    value: "ASC",
+    label: "A-Z"
+  },
+  desc: {
+    value: "DESC",
+    label: "Z-A"
+  }
+};
+export const WEB_CONNECTION = {
+  methods: {
+    PRINTERS_LIST: "pList",
+    LOCAL_PRINTING: "localPrinting",
+    IMPRESSAO_DIRETA: "impressaoDireta",
+    IMPRESSAO_DIRETA_TEXTO: "impressaoDiretaTexto",
+    INFO: "info",
+    PDF_VIEWER: "pdfViewer",
+    IMPORT_IMAGE: "importImage"
+  }
+};
+export var SIMPLE_CRUD_MODE;
+(function (SIMPLE_CRUD_MODE) {
+  SIMPLE_CRUD_MODE[SIMPLE_CRUD_MODE["SERVER"] = 0] = "SERVER";
+  SIMPLE_CRUD_MODE[SIMPLE_CRUD_MODE["IN_MEMORY"] = 1] = "IN_MEMORY";
+})(SIMPLE_CRUD_MODE || (SIMPLE_CRUD_MODE = {}));

package/dist/collection/lib/utils/fileViewer/index.js

@@ -0,0 +1,11 @@
+import { ApplicationContext } from '@sankhyalabs/core';
+import { ApplicationUtils } from '@sankhyalabs/ezui/dist/collection/utils';
+function getMessage(application, key, params) {
+  var _a;
+  return (_a = application === null || application === void 0 ? void 0 : application.messagesBuilder) === null || _a === void 0 ? void 0 : _a.getMessage(key, params);
+}
+export default function fileViewer({ fileSessionKey, isDownload }) {
+  const application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+  window.open(`${window.location.protocol}//${window.location.hostname}:${window.location.port}/mge/visualizadorArquivos.mge?chaveArquivo=${fileSessionKey}${isDownload ? "&download=S" : ""}`);
+  ApplicationUtils.info(getMessage(application, "fileViewer.message.exportSuccess"), { iconName: "check" });
+}

package/dist/collection/lib/utils/fileViewer/interfaces/IFileViewerParams.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/utils/pesquisa.js

@@ -0,0 +1,16 @@
+const mockByEntity = {
+  "ImplantacaoSaldoConta": [{ "value": 6, "label": "Conta Financeiro" }, { "value": 7, "label": "Conta Banco do Brasil" }],
+  "HistoricoBancario": [{ "value": 9, "label": "Lanç. Origem" }, { "value": 8, "label": "Lanç. Origem 2" }],
+  "ContaDestino": [{ "value": 10, "label": "Conta BB" }, { "value": 7, "label": "Conta Santander" }],
+  "HistoricoBancarioDestino": [{ "value": 11, "label": "Contra Bradesco" }, { "value": 13, "label": "Contra Destino" }],
+  "Usuario": [{ "value": 0, "label": "SUP" }],
+  "ContaBancaria": [{ "value": 10, "label": "Conta 10" }, { "value": 17, "label": "Conta 17" }],
+  "TipoOperacao": [{ "value": 4, "label": "Entrada NFse" }, { "value": 5, "label": "Outra top" }, { "value": 6, "label": "Top 6" }]
+};
+export const pesquisaLoadOptions = (searchArgument, fieldName, dataUnit) => {
+  var _a;
+  console.log(searchArgument);
+  const field = dataUnit.getField(fieldName);
+  const entityName = (_a = field.properties) === null || _a === void 0 ? void 0 : _a.ENTITYNAME;
+  return (mockByEntity[entityName] || []);
+};

package/dist/collection/lib/utils/urlutils.js

@@ -0,0 +1,25 @@
+export default class UrlUtils {
+  static getQueryParams(queryString) {
+    const params = new Map();
+    const re = /[?&]?([^=]+)=([^&]*)/g;
+    let tokens;
+    //Necessário por causa da tela Histórico Padrão que possui resourceID com acento
+    queryString = window.unescape(queryString);
+    queryString = queryString.split("+").join(" ");
+    while ((tokens = re.exec(queryString))) {
+      params.set(window.decodeURIComponent(tokens[1]), tokens[2]);
+    }
+    //Inserimos a urlBase no params.
+    params.set("urlBase", this.getUrlBase());
+    if (window["moduleID"] && window["URIServiceBroker"]) {
+      params.set("moduleID", window["moduleID"]);
+      params.set("URIServiceBroker", window["URIServiceBroker"]);
+    }
+    return params;
+  }
+  static getUrlBase() {
+    if (window['mock_url'])
+      return window['mock_url'];
+    return `${location.protocol}//${location.hostname}${location.port ? ":" + location.port : ""}`;
+  }
+}

package/dist/collection/lib/workspace/workspace.js

@@ -0,0 +1,19 @@
+var _a;
+export default class Workspace {
+  static openAppActivity(resourceId, pkObject) {
+    var _a;
+    (_a = window["workspace"]) === null || _a === void 0 ? void 0 : _a.openAppActivity(resourceId, pkObject);
+  }
+  static getAppLabel(resourceID) {
+    if ((window === null || window === void 0 ? void 0 : window["workspace"]) == undefined) {
+      return;
+    }
+    if (window["workspace"].getAppLabel == undefined) {
+      window["workspace"].getAppLabel = (id) => {
+        return (id || "").split(".").pop();
+      };
+    }
+    return window["workspace"].getAppLabel(resourceID);
+  }
+}
+Workspace.resourceID = (_a = window["workspace"]) === null || _a === void 0 ? void 0 : _a.resourceID;

package/dist/components/AuthorizationConfig.js

@@ -0,0 +1,7 @@
+var AuthorizationConfig;
+(function (AuthorizationConfig) {
+  AuthorizationConfig["CONFIG_GRID"] = "CONFIG_GRID";
+  AuthorizationConfig["CONFIG"] = "CONFIG";
+})(AuthorizationConfig || (AuthorizationConfig = {}));
+
+export { AuthorizationConfig as A };

package/dist/components/ConfigStorage.js

@@ -0,0 +1,306 @@
+import { ApplicationContext } from '@sankhyalabs/core';
+import { F as FormConfigFetcher } from './form-config-fetcher.js';
+import { R as ResourceFetcher } from './resource-fetcher.js';
+import { F as FilterBarConfigFetcher } from './filter-bar-config-fetcher.js';
+import { d as dist, D as DataFetcher } from './DataFetcher.js';
+
+class GridConfigFetcher extends ResourceFetcher {
+  constructor() {
+    super(...arguments);
+    this.GRID_CONFIG_VERSION = "V3:";
+  }
+  getConfig(gridName, resourceID) {
+    const completePath = this.getPath(resourceID, gridName);
+    return new Promise((resolve, reject) => {
+      this.loadResource(completePath)
+        .then(loadedResource => {
+        let config = undefined;
+        if (loadedResource) {
+          config = JSON.parse(loadedResource);
+        }
+        resolve(config);
+      }).catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  saveConfig(config, gridName, resourceID) {
+    const completePath = this.getPath(resourceID, gridName);
+    return new Promise((resolve, reject) => {
+      this.saveResource(config, completePath)
+        .then((resp) => {
+        resolve(JSON.parse(resp.resource));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  getPath(resourceID, name) {
+    if (name) {
+      return `cfg://grid/${this.GRID_CONFIG_VERSION}${resourceID}/${name}`;
+    }
+    return `cfg://grid/${this.GRID_CONFIG_VERSION}${resourceID}`;
+  }
+}
+
+class PersonalizedFilterFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this.buildTemplates();
+  }
+  resolveURI(resourceID, configName) {
+    let uri = "filter-assistent-config://" + resourceID;
+    if (configName) {
+      uri += "." + configName;
+    }
+    return uri;
+  }
+  buildTemplates() {
+    this.templateByQuery.set("fetchFilterFields", dist.gql `
+    query($name: String!) {
+      $queryAlias$: fetchFilterFields(name: $name){
+        currentLink {
+          description
+          uri
+        }
+        links {
+          description
+          uri
+          fieldCount
+        }
+        fields {
+          name
+          description
+          uri
+          onlyDate
+          dataType
+          userInterface
+          entityName
+          properties {
+            name
+            value
+          }
+        }
+      }
+    }
+    `);
+    this.templateByQuery.set("fetchFilterAssistent", dist.gql `
+    query($name: String!) {
+      $queryAlias$: fetchFilterAssistent(name: $name) {
+        id
+        name
+        active
+        expression
+        warningMessage
+        assistent
+      }
+    }`);
+    this.templateByQuery.set("savePersonalizedFilter", dist.gql ` 
+    mutation($name: String!, $filterAssistent: InputFilterAssistent!)  {
+      $queryAlias$: savePersonalizedFilter(name: $name, filterAssistent: $filterAssistent) {
+        id
+        name
+      }
+    }`);
+    this.templateByQuery.set("deletePersonalizedFilter", dist.gql `
+    mutation($name: String!, $filterId: String!) {
+      $queryAlias$: deletePersonalizedFilter(name: $name, filterId: $filterId) {
+        id
+        name
+      }
+    }`);
+    this.templateByQuery.set("validateExpression", dist.gql `
+    query($dataUnitName: String!, $expression: String!) {
+      $queryAlias$: validateExpression(dataUnitName: $dataUnitName, expression: $expression) {
+        valid
+        message
+      }
+    }`);
+  }
+  async loadPersonalizedFilter(resourceID, filterID, configName) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID },
+        query: this.templateByQuery.get("fetchFilterAssistent"),
+      })
+        .then((resp) => {
+        resp.assistent = JSON.parse(resp.assistent);
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
+    let personalizedFilterParsed = JSON.parse(JSON.stringify(personalizedFilter));
+    personalizedFilterParsed.assistent = JSON.stringify(personalizedFilterParsed.assistent);
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { name: this.resolveURI(resourceID, configName), filterAssistent: personalizedFilterParsed },
+        query: this.templateByQuery.get("savePersonalizedFilter"),
+      })
+        .then((resp) => {
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  async removePersonalizedFilter(personalizedFilter, resourceID, configName) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { name: this.resolveURI(resourceID, configName), filterId: personalizedFilter.id },
+        query: this.templateByQuery.get("deletePersonalizedFilter"),
+      })
+        .then((resp) => {
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  async validatePersonalizedFilter(dataUnitName, expression) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { dataUnitName: dataUnitName, expression: expression },
+        query: this.templateByQuery.get("validateExpression"),
+      })
+        .then((resp) => {
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadFields(uri) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.get()
+        .callGraphQL({
+        values: { name: uri },
+        query: this.templateByQuery.get("fetchFilterFields"),
+      })
+        .then((resp) => {
+        var _a;
+        let fields = resp.fields;
+        for (const field of fields) {
+          if (Array.isArray(field.properties) && field.properties.length > 0) {
+            const propertiesConvertedObject = field.properties.reduce((accumulator, prop) => {
+              accumulator[prop.name] = prop.value;
+              return accumulator;
+            }, {});
+            field.properties = propertiesConvertedObject;
+          }
+          if ((_a = field === null || field === void 0 ? void 0 : field.properties) === null || _a === void 0 ? void 0 : _a.options) {
+            field.properties.options = JSON.parse(field.properties.options);
+          }
+        }
+        resolve(Object.assign(Object.assign({}, resp), { fields: fields }));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+}
+
+const CONFIG_SOURCE = {
+  form: "form",
+  grid: "grid",
+  filterBar: "filterBar"
+};
+class ConfigStorage {
+  static async get() {
+    if (!ConfigStorage.instance) {
+      const application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+      if (application != undefined) {
+        const configName = application.configName;
+        const resourceID = await application.getResourceID();
+        ConfigStorage.instance = new ConfigStorage();
+        ConfigStorage.resourceID = resourceID;
+        ConfigStorage.instance.loadFormConfig(configName);
+        ConfigStorage.instance.loadGridConfig(configName);
+      }
+    }
+    return this.instance;
+  }
+  async loadFilterBarConfig(name, urlParams) {
+    const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.filterBar);
+    if (!ConfigStorage.configById.has(cacheID)) {
+      ConfigStorage.configById.set(cacheID, ConfigStorage.filterBarConfigFetcher.getConfig(ConfigStorage.resourceID, name, urlParams));
+    }
+    return ConfigStorage.configById.get(cacheID);
+  }
+  async loadFormConfig(name) {
+    const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.form);
+    if (!ConfigStorage.configById.has(cacheID)) {
+      ConfigStorage.configById.set(cacheID, ConfigStorage.formConfigFetcher.loadFormConfig(name, ConfigStorage.resourceID));
+    }
+    return ConfigStorage.configById.get(cacheID);
+  }
+  async loadGridConfig(name) {
+    const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.grid);
+    if (!ConfigStorage.configById.has(cacheID)) {
+      ConfigStorage.configById.set(cacheID, ConfigStorage.gridConfigFetcher.getConfig(name, ConfigStorage.resourceID));
+    }
+    return ConfigStorage.configById.get(cacheID);
+  }
+  static async saveFilterBarConfig(config, name) {
+    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.filterBar);
+    this.configById.delete(cacheID);
+    return this.filterBarConfigFetcher.saveConfig(config, this.resourceID, name);
+  }
+  static async saveFormConfig(config, name) {
+    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.form);
+    this.configById.delete(cacheID);
+    return this.formConfigFetcher.saveConfig(config, name, this.resourceID);
+  }
+  static async saveCardState(config, name) {
+    return this.formConfigFetcher.saveCardState(config, name, this.resourceID);
+  }
+  static async saveGridConfig(config, name) {
+    if (config == undefined) {
+      return;
+    }
+    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.grid);
+    this.configById.delete(cacheID);
+    return this.gridConfigFetcher.saveConfig(config, name, this.resourceID);
+  }
+  static async loadPersonalizedFilter(filterId, configName) {
+    return this.personalizedFilterFetcher.loadPersonalizedFilter(this.resourceID, filterId, configName);
+  }
+  static async savePersonalizedFilter(personalizedFilter, configName) {
+    //Ao criar ou alterar um filtro personalizado, 
+    //precisamos remover o cache do status da filterbar.
+    const cacheID = this.buildCacheID(configName, CONFIG_SOURCE.filterBar);
+    this.configById.delete(cacheID);
+    return this.personalizedFilterFetcher.savePersonalizedFilter(personalizedFilter, this.resourceID, configName);
+  }
+  static async removePersonalizedFilter(personalizedFilter, configName) {
+    return this.personalizedFilterFetcher.removePersonalizedFilter(personalizedFilter, this.resourceID, configName);
+  }
+  static async validatePersonalizedFilter(dataUnitName, expression) {
+    return this.personalizedFilterFetcher.validatePersonalizedFilter(dataUnitName, expression);
+  }
+  static buildCacheID(name, source) {
+    if (name == undefined) {
+      return `req_${source}_${this.resourceID}`;
+    }
+    return `req_${source}_${name}_${this.resourceID}`;
+  }
+}
+ConfigStorage.configById = new Map();
+ConfigStorage.filterBarConfigFetcher = new FilterBarConfigFetcher();
+ConfigStorage.formConfigFetcher = new FormConfigFetcher();
+ConfigStorage.gridConfigFetcher = new GridConfigFetcher();
+ConfigStorage.personalizedFilterFetcher = new PersonalizedFilterFetcher();
+
+export { ConfigStorage as C, GridConfigFetcher as G, PersonalizedFilterFetcher as P };