@sankhyalabs/sankhyablocks 8.15.0-dev.4 → 8.15.0-dev.41

package/dist/collection/lib/http/data-fetcher/fetchers/{fecthAttach → AttachFetcher}/interfaces/ISave.js

@@ -3,4 +3,5 @@ export var SaveErrorsEnum;
   SaveErrorsEnum["LINK_AND_FILE_AT_THE_SAME_TIME"] = "LINK_AND_FILE_AT_THE_SAME_TIME";
   SaveErrorsEnum["ANY_LINK_OR_FILE_FILLED"] = "ANY_LINK_OR_FILE_FILLED";
   SaveErrorsEnum["UNKNOWN"] = "UNKNOWN";
+  SaveErrorsEnum["DESCRIPTION_CANNOT_BE_CHANGED"] = "DESCRIPTION_CANNOT_BE_CHANGED";
 })(SaveErrorsEnum || (SaveErrorsEnum = {}));

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/dataunit-fetcher.js

@@ -171,14 +171,41 @@ export default class DataUnitFetcher {
       });
     });
   }
+  addTransientProperties(dataUnit, updatingFields) {
+    const loaderProps = dataUnit.getGlobalLoaderProps();
+    if (loaderProps == undefined || loaderProps.size === 0) {
+      return updatingFields;
+    }
+    if (updatingFields == undefined) {
+      updatingFields = {};
+    }
+    Array.from(loaderProps.entries()).forEach(([name, value]) => {
+      updatingFields[`transient.${name}`] = value;
+    });
+    return updatingFields;
+  }
+  getUpdatingFields(dataUnit, originalUpdatingFields) {
+    if (originalUpdatingFields == undefined) {
+      return;
+    }
+    const updatingFields = Object.assign({}, originalUpdatingFields);
+    Object.keys(updatingFields).forEach(key => {
+      const descriptor = dataUnit.getField(key);
+      if (descriptor != undefined && descriptor.standAlone) {
+        delete updatingFields[key];
+      }
+    });
+    return this.addTransientProperties(dataUnit, updatingFields);
+  }
   saveData(dataUnit, duChanges) {
     const updatedRecordsIds = [];
     const addedRecordsIds = [];
     const changes = duChanges.map((change) => {
-      const { dataUnit: changeDU, record, updatingFields, operation } = change;
+      const { dataUnit: changeDU, record, operation } = change;
       const dataUnitInstance = DataUnitStorage.get(changeDU);
+      const updatingFields = this.getUpdatingFields(dataUnitInstance, change.updatingFields);
       let parsedUpdatingFields;
-      if (updatingFields) {
+      if (updatingFields != undefined) {
         parsedUpdatingFields = Object.entries(updatingFields).map(([fieldName, value]) => {
           const descriptor = dataUnitInstance.getField(fieldName);
           const dataType = descriptor ? descriptor.dataType : DataType.TEXT;
@@ -226,7 +253,8 @@ export default class DataUnitFetcher {
           }
           responseRecord.fields.forEach(({ name, value }) => {
             var _a;
-            duRecord[name] = ((_a = dataUnitInstance === null || dataUnitInstance === void 0 ? void 0 : dataUnitInstance.valueFromString) === null || _a === void 0 ? void 0 : _a.call(dataUnitInstance, name, value)) || value;
+            const valueFromString = (_a = dataUnitInstance === null || dataUnitInstance === void 0 ? void 0 : dataUnitInstance.valueFromString) === null || _a === void 0 ? void 0 : _a.call(dataUnitInstance, name, value);
+            duRecord[name] = (valueFromString !== undefined) ? valueFromString : value;
           });
           dataUnitRecords.push(duRecord);
         });

package/dist/collection/lib/http/data-fetcher/fetchers/data-unit/loadstrategy/DatasetStrategy.js

@@ -6,30 +6,39 @@ export class DatasetStrategy {
   canSlice() {
     return false;
   }
+  processSortingSide(request, dataUnit, serverSideFilters) {
+    const localSorting = [];
+    const serverSorting = [];
+    if (request.sort != undefined) {
+      if (serverSideFilters.length === 0) {
+        return { localSorting: request.sort, serverSorting: [] };
+      }
+      for (const sort of request.sort) {
+        const descriptor = dataUnit.getField(sort.field);
+        const local = descriptor != undefined
+          && descriptor.properties != undefined
+          && descriptor.properties.calculated === "true";
+        if (local) {
+          localSorting.push(sort);
+        }
+        else {
+          serverSorting.push(sort);
+        }
+      }
+    }
+    return { localSorting, serverSorting };
+  }
   async load(dataUnit, request, loadingInfo) {
+    var _a, _b;
     if (dataUnit.metadata == undefined) {
       return Promise.resolve({ records: [], loadingInfo });
     }
     try {
-      const localSorting = [];
-      const serverSorting = [];
-      if (request.sort != undefined) {
-        for (const sort of request.sort) {
-          const descriptor = dataUnit.getField(sort.field);
-          const local = descriptor != undefined
-            && descriptor.properties != undefined
-            && descriptor.properties.calculated === "true";
-          if (local) {
-            localSorting.push(sort);
-          }
-          else {
-            serverSorting.push(sort);
-          }
-        }
-      }
+      const serverSideFilters = (_b = (_a = request.filters) === null || _a === void 0 ? void 0 : _a.filter(filter => !filter.name.startsWith("FILTRO_COLUNA_"))) !== null && _b !== void 0 ? _b : [];
+      const { localSorting, serverSorting } = this.processSortingSide(request, dataUnit, serverSideFilters);
       const fields = this.getFieldsList(dataUnit);
       const serviceName = "DatasetSP.loadRecords";
-      const requestBody = this.buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, serverSorting);
+      const requestBody = this.buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, serverSorting, serverSideFilters);
       const params = loadingInfo.quiet ? { urlParams: { quietMode: "true" } } : undefined;
       const { result: responseRecords, pagerID: pagerId } = await DataFetcher.get().callServiceBroker(serviceName, requestBody, params);
       const records = this.processRecords(dataUnit, fields, responseRecords);
@@ -51,13 +60,21 @@ export class DatasetStrategy {
   getFieldsList(dataUnit) {
     let fields = ["__record__id__", "__record__label__"];
     dataUnit.metadata.fields.forEach((descriptor) => {
-      if (descriptor.standAlone) {
+      if (descriptor.standAlone)
         return;
-      }
       fields = fields.concat(this.getFieldNames(descriptor));
     });
     return fields;
   }
+  getStandAloneFieldsList(dataUnit) {
+    let fields = {};
+    dataUnit.metadata.fields.forEach((currentField) => {
+      if (!currentField.standAlone)
+        return;
+      fields = Object.assign(Object.assign({}, fields), { [currentField.name]: { fieldType: currentField.dataType, userType: currentField.userInterface } });
+    });
+    return fields;
+  }
   getFieldNames(descriptor) {
     const descriptionField = this.getSearchDescriptionField(descriptor);
     if (descriptionField == undefined) {
@@ -65,7 +82,7 @@ export class DatasetStrategy {
     }
     return [descriptor.name, descriptionField];
   }
-  buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, sorting) {
+  buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo, sorting, serverSideFilters) {
     const dataSetID = dataUnit.dataUnitId;
     const dataUnitName = dataUnit.name;
     const entityName = DataUnitFetcher.parseDataUnitName(dataUnitName).entityName;
@@ -80,14 +97,11 @@ export class DatasetStrategy {
         totalRecordsCount: loadingInfo.count,
         pagerID: loadingInfo.pagerId,
         standAlone: false,
-        standAloneFieldsMD: {
-          __record__id__: { "fieldType": "S", "userType": "P" },
-          __record__label__: { "fieldType": "S", "userType": "P" }
-        },
+        standAloneFieldsMD: Object.assign({ __record__id__: { "fieldType": "S", "userType": "P" }, __record__label__: { "fieldType": "S", "userType": "P" } }, this.getStandAloneFieldsList(dataUnit)),
         tryJoinedFields: true,
         parallelLoader: useParallelLoader,
         crudListener: `br.com.sankhya.bff.${this.getModuleName()}.BFFDataUnitDatasetAdapter`,
-        txProperties: this.getTxProperties(dataUnitName, request, sorting),
+        txProperties: this.getTxProperties(dataUnit, request, sorting, serverSideFilters),
         useDefaultRowsLimit: false
       }
     };
@@ -98,12 +112,10 @@ export class DatasetStrategy {
     const moduleName = app.getModuleName();
     return moduleName.replace("-bff", "");
   }
-  getTxProperties(dataUnitName, request, sorting) {
-    var _a, _b;
+  getTxProperties(dataUnit, request, sorting, serverSideFilters) {
     const txProperties = {
-      "__DATA_UNIT_ADAPTER__[dataUnitName]": dataUnitName
+      "__DATA_UNIT_ADAPTER__[dataUnitName]": dataUnit.name
     };
-    const serverSideFilters = (_b = (_a = request.filters) === null || _a === void 0 ? void 0 : _a.filter(filter => !filter.name.startsWith("FILTRO_COLUNA_"))) !== null && _b !== void 0 ? _b : [];
     if (serverSideFilters.length !== 0) {
       txProperties["__DATA_UNIT_ADAPTER__[criteria]"] = JSON.stringify(serverSideFilters);
     }
@@ -113,6 +125,13 @@ export class DatasetStrategy {
     if (request.parentRecordId != undefined) {
       txProperties["__DATA_UNIT_ADAPTER__[parentRecordId]"] = request.parentRecordId;
     }
+    const loaderProps = dataUnit.getGlobalLoaderProps();
+    if (loaderProps == undefined || loaderProps.size === 0) {
+      return txProperties;
+    }
+    Array.from(loaderProps.entries()).forEach(([name, value]) => {
+      txProperties[name] = value;
+    });
     return txProperties;
   }
   processRecords(dataUnit, fields, responseRecords) {

package/dist/collection/lib/http/data-fetcher/fetchers/parameters-fecher.js

@@ -3,7 +3,22 @@ import { DateUtils, StringUtils, ObjectUtils } from "@sankhyalabs/core";
 import { DataFetcher } from "../DataFetcher";
 export default class ParametersFetcher {
   constructor() {
+    this._embeddedParams = new Map();
     this.templateByQuery = new Map();
+    try {
+      if (window["MGE_PARAMS"] != undefined) {
+        const source = atob(window['MGE_PARAMS']);
+        const params = source.split('__;__');
+        params.forEach(param => {
+          const [key, value] = param.split("__=__");
+          this._embeddedParams.set(key, value);
+        });
+      }
+    }
+    catch (error) {
+      console.error("Problemas ao obter parâmetros embarcados");
+      console.error(error);
+    }
     this.buldTemplates();
   }
   buldTemplates() {
@@ -15,6 +30,9 @@ export default class ParametersFetcher {
         }`);
   }
   async getParam(name) {
+    if (this._embeddedParams.has(name)) {
+      return Promise.resolve(this._embeddedParams.get(name));
+    }
     const completPath = `param://application?params=${name}`;
     return DataFetcher.get().callGraphQL({
       values: { name: completPath },
@@ -52,6 +70,9 @@ export default class ParametersFetcher {
     if (Array.isArray(obj) && obj.length > 0) {
       obj = obj[0];
     }
+    if (typeof obj === "string") {
+      return obj;
+    }
     if (StringUtils.isEmpty(obj.resource))
       return "";
     try {

package/dist/collection/lib/http/data-fetcher/fetchers/personalized-filter-fetcher.js

@@ -52,7 +52,7 @@ export default class PersonalizedFilterFetcher {
         assistent
       }
     }`);
-    this.templateByQuery.set("savePersonalizedFilter", gql ` 
+    this.templateByQuery.set("savePersonalizedFilter", gql `
     mutation($name: String!, $filterAssistent: InputFilterAssistent!)  {
       $queryAlias$: savePersonalizedFilter(name: $name, filterAssistent: $filterAssistent) {
         id
@@ -74,11 +74,11 @@ export default class PersonalizedFilterFetcher {
       }
     }`);
   }
-  async loadPersonalizedFilter(resourceID, filterID, configName) {
+  async loadPersonalizedFilter(resourceID, filterID, configName, legacyConfigName) {
     return new Promise((resolve, reject) => {
       DataFetcher.get()
         .callGraphQL({
-        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID },
+        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID + this.resolveLegacyConfigName(legacyConfigName) },
         query: this.templateByQuery.get("fetchFilterAssistent"),
       })
         .then((resp) => {
@@ -90,6 +90,9 @@ export default class PersonalizedFilterFetcher {
       });
     });
   }
+  resolveLegacyConfigName(legacyConfigName) {
+    return legacyConfigName ? `?legacyResourceID=${legacyConfigName}` : '';
+  }
   async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
     if (!personalizedFilter || Object.keys(personalizedFilter).length == 0) {
       return Promise.reject(new Error("personalizedFilter não pode ser vazio"));

package/dist/collection/lib/http/data-fetcher/fetchers/pesquisa-fetcher.js

@@ -1,4 +1,4 @@
-import { DataType } from "@sankhyalabs/core";
+import { ApplicationContext, DataType } from "@sankhyalabs/core";
 import { gql } from "graphql-request";
 import { DataFetcher } from "../DataFetcher";
 export class PesquisaFetcher {
@@ -50,7 +50,7 @@ export class PesquisaFetcher {
     });
   }
   loadAdvancedSearch(entityName, argument, criteria, searchOptions) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const listenerResult = this.applySearchListener(SearchListenerType.beforeSearch, entityName, argument, criteria, searchOptions);
     const values = {
       argument: (listenerResult === null || listenerResult === void 0 ? void 0 : listenerResult.argument) || argument,
@@ -63,10 +63,16 @@ export class PesquisaFetcher {
         $: (_a = values.criteria) === null || _a === void 0 ? void 0 : _a.expression
       }
     };
-    if (((_b = values.criteria) === null || _b === void 0 ? void 0 : _b.params.length) > 0) {
+    if (((_c = (_b = values.criteria) === null || _b === void 0 ? void 0 : _b.params) === null || _c === void 0 ? void 0 : _c.length) > 0) {
       externalCriteria.params = {
         param: values.criteria.params.map(param => {
           let value = param.value;
+          if (typeof value === "string") {
+            const match = /CTX\{([^}]+)\}/.exec(value);
+            if (match) {
+              value = ApplicationContext.getContextValue(`__SNK__APPLICATION__FILTER__CONTEXT(${match[1]})__`);
+            }
+          }
           let type = param.dataType;
           if (type === DataType.OBJECT) {
             value = value.value;
@@ -80,18 +86,11 @@ export class PesquisaFetcher {
       };
     }
     const options = searchOptions != undefined
-      ? {
-        "pkFieldName": searchOptions.codeFieldName,
-        "label": searchOptions.descriptionFieldName,
-        "fieldName": searchOptions.codeFieldName,
-        "useDescriptionOptions": false,
-        "enableRowsCounter": true
-      }
-      : undefined;
+      ? Object.assign(Object.assign({}, searchOptions), { "pkFieldName": searchOptions.codeFieldName, "label": searchOptions.descriptionFieldName, "fieldName": searchOptions.codeFieldName, "useDescriptionOptions": false, "enableRowsCounter": true }) : undefined;
     const reqBody = {
       "serviceName": serviceName,
       "requestBody": {
-        "criteria": Object.assign({ "entityName": entityName, "compacted": false, "ignoreEntityCriteria": false, "limit": this._defaultPageSize, "query": { "$": values.argument }, "orderByDesc": false, "externalCriteria": externalCriteria, "localEntityName": (_c = values.searchOptions) === null || _c === void 0 ? void 0 : _c.rootEntity }, { options }),
+        "criteria": Object.assign({ "entityName": entityName, "compacted": false, "ignoreEntityCriteria": false, "limit": this._defaultPageSize, "query": { "$": values.argument }, "orderByDesc": false, "externalCriteria": externalCriteria, "localEntityName": (_d = values.searchOptions) === null || _d === void 0 ? void 0 : _d.rootEntity }, { options }),
         "clientEventList": {
           "clientEvent": []
         }

package/dist/collection/lib/index.js

@@ -4,7 +4,7 @@ export { CrudUtils } from './utils/CrudUtils';
 export { PresentationMode } from "./@types";
 export { TotalsFetcher } from './http/data-fetcher/fetchers/totals-fetcher';
 export { default as ApplicationConfigFetcher } from './http/data-fetcher/fetchers/application-config-fetcher';
-export { AttachFetcher } from './http/data-fetcher/fetchers/attach-fetcher';
+export { AttachFetcher, AnexoSistemaFetcher } from './http/data-fetcher/fetchers/AttachFetcher';
 export { default as DataUnitFetcher } from './http/data-fetcher/fetchers/data-unit/dataunit-fetcher';
 export { default as FilterBarConfigFetcher } from './http/data-fetcher/fetchers/filter-bar-config-fetcher';
 export { FormConfigFetcher } from './http/data-fetcher/fetchers/form-config-fetcher';

package/dist/collection/lib/message/resources/snk-attach.msg.js

@@ -17,11 +17,24 @@ export const snkAttachMessages = {
     anyLinkOrFileFilled: {
       title: "Atenção",
       message: `É necessário preencher o campo "Link" ou anexar um arquivo.`
+    },
+    descriptionCannotBeChanged: {
+      title: "Atenção",
+      message: "O campo 'Descrição' não pode ser alterado."
     }
   },
   taskbar: {
     titleDownload: "Fazer download",
     titleLink: "Abrir link",
+  },
+  attachMetadata: {
+    lblCode: "Código",
+    lblDescription: "Descrição",
+    lblFileOrLink: "Arquivo / Link",
+    lblUser: "Usuário",
+    lblDate: "Data de alteração",
+    lblFile: "Arquivo",
+    lblSubTitle: "Clique para selecionar um arquivo",
   }
 };
 export default snkAttachMessages;

package/dist/collection/lib/message/resources/snk-data-exporter.msg.js

@@ -16,7 +16,8 @@ export const snkDataExporterMessages = {
   },
   message: {
     emailSuccess: "E-mail enviado com sucesso",
-    exportError: "Usuário sem permissão",
+    exportError: "Falha ao exportar dados",
+    unknownFailure: "O motivo da falha não pode ser identificado.",
     exportPermission: "O usuário não possui permissão para exportar o arquivo.",
   },
   title: {

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

@@ -1,6 +1,18 @@
 import { DataFetcher } from '../';
-import { ApplicationContext } from '@sankhyalabs/core';
+import { ApplicationContext, SortMode } from '@sankhyalabs/core';
 export class CrudUtils {
+  static assertDefaultSorting(gridConfig, dataUnit) {
+    if (gridConfig && dataUnit) {
+      dataUnit.defaultSorting = gridConfig
+        .columns
+        .filter(col => col.ascending != undefined)
+        .sort((colA, colB) => colA.orderIndex - colB.orderIndex)
+        .map(({ name: field, ascending }) => {
+        const { dataType } = dataUnit.getField(field);
+        return { field, dataType, mode: ascending ? SortMode.ASC : SortMode.DESC };
+      });
+    }
+  }
   static find(entityName, fields, criteria, onlyFirst = true, criteriaExpression, orderBy) {
     const SERVICE_CRUD_FIND = "mge@crud.find";
     let parsedFields = [];

package/dist/components/ConfigStorage.js

@@ -232,7 +232,7 @@ class PersonalizedFilterFetcher {
         assistent
       }
     }`);
-    this.templateByQuery.set("savePersonalizedFilter", dist.gql ` 
+    this.templateByQuery.set("savePersonalizedFilter", dist.gql `
     mutation($name: String!, $filterAssistent: InputFilterAssistent!)  {
       $queryAlias$: savePersonalizedFilter(name: $name, filterAssistent: $filterAssistent) {
         id
@@ -254,11 +254,11 @@ class PersonalizedFilterFetcher {
       }
     }`);
   }
-  async loadPersonalizedFilter(resourceID, filterID, configName) {
+  async loadPersonalizedFilter(resourceID, filterID, configName, legacyConfigName) {
     return new Promise((resolve, reject) => {
       DataFetcher.get()
         .callGraphQL({
-        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID },
+        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID + this.resolveLegacyConfigName(legacyConfigName) },
         query: this.templateByQuery.get("fetchFilterAssistent"),
       })
         .then((resp) => {
@@ -270,6 +270,9 @@ class PersonalizedFilterFetcher {
       });
     });
   }
+  resolveLegacyConfigName(legacyConfigName) {
+    return legacyConfigName ? `?legacyResourceID=${legacyConfigName}` : '';
+  }
   async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
     if (!personalizedFilter || Object.keys(personalizedFilter).length == 0) {
       return Promise.reject(new Error("personalizedFilter não pode ser vazio"));
@@ -351,17 +354,37 @@ class PersonalizedFilterFetcher {
   }
 }
 
-const CONFIG_SOURCE = {
-  form: "form",
-  grid: "grid",
-  filterBar: "filterBar"
-};
+var CONFIG_SOURCE;
+(function (CONFIG_SOURCE) {
+  CONFIG_SOURCE["form"] = "form";
+  CONFIG_SOURCE["grid"] = "grid";
+  CONFIG_SOURCE["filterBar"] = "filterBar";
+})(CONFIG_SOURCE || (CONFIG_SOURCE = {}));
 class ConfigStorage {
-  static preload(resourceID, configName) {
+  static addFilterBarLegacyConfig(configName, legacyConfigName) {
+    this.validateConfigName(configName, legacyConfigName);
+    this.filterBarLegacyConfig.set(configName, legacyConfigName);
+  }
+  static addFormLegacyConfig(configName, legacyConfigName) {
+    this.validateConfigName(configName, legacyConfigName);
+    this.formLegacyConfig.set(configName, legacyConfigName);
+  }
+  static addGridLegacyConfig(configName, legacyConfigName) {
+    this.validateConfigName(configName, legacyConfigName);
+    this.gridLegacyConfig.set(configName, legacyConfigName);
+  }
+  static preload(resourceID, configName, legacyConfigs) {
+    if (configName && (legacyConfigs === null || legacyConfigs === void 0 ? void 0 : legacyConfigs.gridLegacyConfig)) {
+      ConfigStorage.addGridLegacyConfig(configName, legacyConfigs.gridLegacyConfig);
+    }
+    if (configName && (legacyConfigs === null || legacyConfigs === void 0 ? void 0 : legacyConfigs.formLegacyConfig)) {
+      ConfigStorage.addFormLegacyConfig(configName, legacyConfigs.formLegacyConfig);
+    }
     ConfigStorage.loadFormConfig(configName, resourceID);
     ConfigStorage.loadGridConfig(configName, resourceID);
   }
   static async loadFilterBarConfig(name, resourceID, urlParams) {
+    urlParams = this.handleLegacyConfig(name, CONFIG_SOURCE.filterBar, urlParams);
     const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.filterBar, resourceID);
     if (!ConfigStorage.configById.has(cacheID)) {
       ConfigStorage.configById.set(cacheID, ConfigStorage.filterBarConfigFetcher.getConfig(resourceID, name, urlParams));
@@ -369,6 +392,7 @@ class ConfigStorage {
     return ConfigStorage.configById.get(cacheID);
   }
   static async loadFormConfig(name, resourceID) {
+    name = this.handleLegacyConfigAsString(name, CONFIG_SOURCE.form);
     const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.form, resourceID);
     if (!ConfigStorage.configById.has(cacheID)) {
       ConfigStorage.configById.set(cacheID, ConfigStorage.formConfigFetcher.loadFormConfig(name, resourceID));
@@ -376,6 +400,7 @@ class ConfigStorage {
     return ConfigStorage.configById.get(cacheID);
   }
   static async loadGridConfig(name, resourceID) {
+    name = this.handleLegacyConfigAsString(name, CONFIG_SOURCE.grid);
     const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.grid, resourceID);
     if (!ConfigStorage.configById.has(cacheID)) {
       ConfigStorage.configById.set(cacheID, ConfigStorage.gridConfigFetcher.getConfig(name, resourceID));
@@ -383,13 +408,12 @@ class ConfigStorage {
     return ConfigStorage.configById.get(cacheID);
   }
   static async saveFilterBarConfig(config, name, resourceID) {
-    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.filterBar, resourceID);
-    this.configById.delete(cacheID);
+    await this.deleteFilterBarConfigCache(name, resourceID);
     return this.filterBarConfigFetcher.saveConfig(config, resourceID, name);
   }
   static async saveFormConfig(config, name, resourceID) {
-    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.form, resourceID);
-    this.configById.delete(cacheID);
+    name = this.handleLegacyConfigAsString(name, CONFIG_SOURCE.form);
+    await this.deleteFormConfigCache(name, resourceID);
     return this.formConfigFetcher.saveConfig(config, name, resourceID);
   }
   static async saveCardState(config, name, resourceID) {
@@ -399,18 +423,17 @@ class ConfigStorage {
     if (config == undefined) {
       return;
     }
-    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.grid, resourceID);
-    this.configById.delete(cacheID);
+    await this.deleteGridConfigCache(name, resourceID);
     return this.gridConfigFetcher.saveConfig(config, name, resourceID);
   }
   static async loadPersonalizedFilter(filterId, resourceID, configName) {
-    return this.personalizedFilterFetcher.loadPersonalizedFilter(resourceID, filterId, configName);
+    const legacyConfigName = this.filterBarLegacyConfig.get(configName);
+    return this.personalizedFilterFetcher.loadPersonalizedFilter(resourceID, filterId, configName, legacyConfigName);
   }
   static async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
-    //Ao criar ou alterar um filtro personalizado, 
+    //Ao criar ou alterar um filtro personalizado,
     //precisamos remover o cache do status da filterbar.
-    const cacheID = this.buildCacheID(configName, CONFIG_SOURCE.filterBar, resourceID);
-    this.configById.delete(cacheID);
+    await this.deleteFilterBarConfigCache(configName, resourceID);
     return this.personalizedFilterFetcher.savePersonalizedFilter(personalizedFilter, resourceID, configName);
   }
   static async removePersonalizedFilter(personalizedFilter, resourceID, configName) {
@@ -419,6 +442,51 @@ class ConfigStorage {
   static async validatePersonalizedFilter(dataUnitName, expression) {
     return this.personalizedFilterFetcher.validatePersonalizedFilter(dataUnitName, expression);
   }
+  static async deleteGridConfigCache(name, resourceID) {
+    await this.deleteConfigCache(name, resourceID, CONFIG_SOURCE.grid);
+  }
+  static async deleteFormConfigCache(name, resourceID) {
+    await this.deleteConfigCache(name, resourceID, CONFIG_SOURCE.form);
+  }
+  static async deleteFilterBarConfigCache(name, resourceID) {
+    await this.deleteConfigCache(name, resourceID, CONFIG_SOURCE.filterBar);
+  }
+  static validateConfigName(configName, legacyConfigName) {
+    if (!configName)
+      throw Error(this.CONFIG_NAME_ERROR_MESSAGE);
+    if (!legacyConfigName)
+      throw Error(this.LEGACY_CONFIG_NAME_ERROR_MESSAGE);
+  }
+  static handleLegacyConfig(configName, configSource, urlParams) {
+    let legacyConfigName;
+    switch (configSource) {
+      case CONFIG_SOURCE.filterBar:
+        legacyConfigName = this.filterBarLegacyConfig.get(configName);
+        break;
+      case CONFIG_SOURCE.grid:
+        legacyConfigName = this.gridLegacyConfig.get(configName);
+        break;
+      case CONFIG_SOURCE.form:
+        legacyConfigName = this.formLegacyConfig.get(configName);
+    }
+    const params = urlParams ? Object.assign({}, urlParams) : {};
+    if (legacyConfigName) {
+      params['legacyResourceID'] = legacyConfigName;
+    }
+    return params;
+  }
+  static handleLegacyConfigAsString(name, source) {
+    const params = this.handleLegacyConfig(name, source);
+    const legacyResourceID = params['legacyResourceID'];
+    if (legacyResourceID) {
+      name = name + `?legacyResourceID=${legacyResourceID}`;
+    }
+    return name;
+  }
+  static async deleteConfigCache(name, resourceID, source) {
+    const cacheID = ConfigStorage.buildCacheID(name, source, resourceID);
+    this.configById.delete(cacheID);
+  }
   static buildCacheID(name, source, resourceID) {
     if (name == undefined) {
       return `req_${source}_${resourceID}`;
@@ -426,6 +494,11 @@ class ConfigStorage {
     return `req_${source}_${name}_${resourceID}`;
   }
 }
+ConfigStorage.CONFIG_NAME_ERROR_MESSAGE = "ConfigName precisa ser informado.";
+ConfigStorage.LEGACY_CONFIG_NAME_ERROR_MESSAGE = "LegacyConfigName precisa ser informado.";
+ConfigStorage.filterBarLegacyConfig = new Map();
+ConfigStorage.formLegacyConfig = new Map();
+ConfigStorage.gridLegacyConfig = new Map();
 ConfigStorage.configById = new Map();
 ConfigStorage.filterBarConfigFetcher = new FilterBarConfigFetcher();
 ConfigStorage.formConfigFetcher = new FormConfigFetcher();

package/dist/components/DataFetcher.js

@@ -6786,7 +6786,6 @@ class DataFetcher {
         if (http.readyState == 4 && http.status == 200) {
           try {
             const jsonResp = JSON.parse(http.responseText);
-            await this.processServiceBrokerClientEvents({ clientEvents: jsonResp === null || jsonResp === void 0 ? void 0 : jsonResp.clientEvents, serviceName, payloadJson, accept, reject });
             /**
              * Este trecho difere do projeto HTML5 devido à decisão de adotar uma abordagem síncrona para esta chamada. Isso é justificado pelo fato de que, no cenário em questão, a abordagem assíncrona teria impactos negativos.
              *
@@ -6797,8 +6796,10 @@ class DataFetcher {
             if (this.isServiceBrokerError(jsonResp)) {
               reject(this.processServiceBrokerErrorInfo(jsonResp));
             }
-            else if (jsonResp.status == DataFetcher.SERVICE_BROKER_STATUS.SERVICE_CANCELED && jsonResp.statusMessage) {
-              console.debug(`[DataFetcher] ${jsonResp.statusMessage}`);
+            else if (jsonResp.status == DataFetcher.SERVICE_BROKER_STATUS.SERVICE_CANCELED) {
+              if (jsonResp.statusMessage) {
+                console.debug(`[DataFetcher] ${jsonResp.statusMessage}`);
+              }
             }
             else {
               accept(jsonResp.responseBody);
@@ -6806,6 +6807,7 @@ class DataFetcher {
                 (_a = this.application) === null || _a === void 0 ? void 0 : _a.info(jsonResp.statusMessage);
               }
             }
+            this.processServiceBrokerClientEvents({ clientEvents: jsonResp === null || jsonResp === void 0 ? void 0 : jsonResp.clientEvents, serviceName, payloadJson, accept, reject });
           }
           catch (err) {
             console.warn(`Erro ao executar serviço: ${err}`);