@sankhyalabs/sankhyablocks 0.0.0-feat-dev-KB-18468.2 → 0.0.0-feat-dev-25080.0

package/dist/cjs/{ConfigStorage-c26705cc.js → ConfigStorage-c15716fd.js}

@@ -1,9 +1,9 @@
 'use strict';
 
-const formConfigFetcher = require('./form-config-fetcher-037d16de.js');
+const formConfigFetcher = require('./form-config-fetcher-17775a75.js');
 const filterItemType_enum = require('./filter-item-type.enum-aa823a00.js');
 const core = require('@sankhyalabs/core');
-const DataFetcher = require('./DataFetcher-3f9e6ee2.js');
+const DataFetcher = require('./DataFetcher-713f0749.js');
 
 class GridConfigFetcher extends formConfigFetcher.ResourceFetcher {
   constructor() {
@@ -273,6 +273,9 @@ class PersonalizedFilterFetcher {
     });
   }
   async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
+    if (!personalizedFilter || Object.keys(personalizedFilter).length == 0) {
+      return Promise.reject(new Error("personalizedFilter não pode ser vazio"));
+    }
     let personalizedFilterParsed = JSON.parse(JSON.stringify(personalizedFilter));
     personalizedFilterParsed.assistent = JSON.stringify(personalizedFilterParsed.assistent);
     return new Promise((resolve, reject) => {

package/dist/cjs/{DataFetcher-3f9e6ee2.js → DataFetcher-713f0749.js}

@@ -6524,7 +6524,6 @@ var __asyncValues = (undefined && undefined.__asyncValues) || function (o) {
 };
 class DataFetcher {
   constructor() {
-    this.GRAPHQL_PATH = `/${window.MGE_MODULE_NAME || 'mgefin-bff'}/graphql`;
     this.ready = true;
     this.watingRequestsById = new Map();
   }
@@ -6546,6 +6545,12 @@ class DataFetcher {
     this.instance.application = core.ApplicationContext.getContextValue("__SNK__APPLICATION__");
     return this.instance;
   }
+  static getGraphQLPath() {
+    if (core.StringUtils.isEmpty(this.instance.graphqlPath) && this.instance.application != undefined) {
+      this.instance.graphqlPath = `/${this.instance.application.getModuleName()}/graphql`;
+    }
+    return this.instance.graphqlPath;
+  }
   static addRequestListener(listener) {
     const index = DataFetcher.requestListener.indexOf(listener);
     if (index < 0) {
@@ -6595,7 +6600,7 @@ class DataFetcher {
     }
     return new core.ErrorException(title, statusMessage, tsErrorCode);
   }
-  async callGraphQL(req) {
+  async callGraphQL(req, quietMode = false) {
     var _a;
     if (this.ready) {
       this.pause();
@@ -6613,22 +6618,22 @@ class DataFetcher {
     if (this.ready) {
       return new Promise(async (resolve, reject) => {
         let query = this.getQueryTemplate(req);
-        const res = await this.fecthGrapql([{ document: query, variables: req.values }]);
+        const res = await this.fecthGraphQL([{ document: query, variables: req.values }], quietMode);
         if (res.errors.length > 0) {
-          if (!this.proccesGraphQLClientEvents(res === null || res === void 0 ? void 0 : res.extensions, req, resolve, reject)) {
+          if (!(await this.proccesGraphQLClientEvents(res === null || res === void 0 ? void 0 : res.extensions, req, resolve, reject))) {
             const error = this.processGraphQlErrorInfo(res.errors);
             reject(error);
           }
         }
         else {
           resolve(res.data[0][reqKey]);
-          this.proccesGraphQLClientEvents(res === null || res === void 0 ? void 0 : res.extensions, req, resolve, reject);
+          await this.proccesGraphQLClientEvents(res === null || res === void 0 ? void 0 : res.extensions, req, resolve, reject);
         }
       });
     }
     else {
       if (!this.watingRequestsById.has(reqKey)) {
-        this.watingRequestsById.set(reqKey, new WaitingRequest(req));
+        this.watingRequestsById.set(reqKey, new WaitingRequest(req, quietMode));
       }
       return (_a = this.watingRequestsById.get(reqKey)) === null || _a === void 0 ? void 0 : _a.promise;
     }
@@ -6636,7 +6641,7 @@ class DataFetcher {
   resolveURL() {
     return UrlUtils.getUrlBase();
   }
-  proccesGraphQLClientEvents(extensions, originalRequest, resolve, reject) {
+  async proccesGraphQLClientEvents(extensions, originalRequest, resolve, reject) {
     if (extensions == undefined) {
       return false;
     }
@@ -6651,8 +6656,8 @@ class DataFetcher {
           throw new core.WarningException("ClientEvent não registrado", `Ocorreu o client event ${id} porém não há client event registrado na aplicação.`);
         }
         const handlers = DataFetcher.clientEventsByID.get(id);
-        handlers.forEach(handler => {
-          handler({ id, content: JSON.parse(clientEvents[id]) }, new GraphQLRecaller(originalRequest, resolve, reject));
+        handlers.forEach(async (handler) => {
+          await handler({ id, content: JSON.parse(clientEvents[id]) }, new GraphQLRecaller(originalRequest, resolve, reject));
         });
       }
       return Object.keys(clientEvents).length > 0;
@@ -6726,9 +6731,9 @@ class DataFetcher {
     const urlParams = UrlUtils.getQueryParams(location.search);
     return {
       baseUrl: `${this.resolveURL()}/${module}/service.sbr`,
-      appName: "SankhyaBlocks",
+      appName: window['APPLICATION_NAME'] || "SankhyaBlocks",
       mgeSession: `${window['mgeSession'] || urlParams.get("mgeSession")}`,
-      globalID: "85C0093DFA240EAB699B4E47A10215BD",
+      globalID: window['GLOBALID'] || core.StringUtils.generateUUID(),
       resourceID: (window["resourceID"] || ((_a = window["workspace"]) === null || _a === void 0 ? void 0 : _a.resourceID))
     };
   }
@@ -6844,16 +6849,14 @@ class DataFetcher {
   }
   async executePendingRequest(watingRequestsById) {
     const requestsBatch = [];
-    watingRequestsById.forEach(async (waitingReq) => {
-      let query = this.getQueryTemplate(waitingReq.request);
+    let quietMode = true;
+    watingRequestsById.forEach((waitingReq) => {
+      const query = this.getQueryTemplate(waitingReq.request);
       requestsBatch.push({ document: query, variables: Object.assign({}, waitingReq.request.values) });
+      quietMode = quietMode && waitingReq.quietMode;
     });
-    let res = undefined;
-    let dataResponse = [];
-    let errorsResponse = [];
-    res = await this.fecthGrapql(requestsBatch);
-    dataResponse = res.data;
-    errorsResponse = res.errors;
+    const response = await this.fecthGraphQL(requestsBatch, quietMode);
+    const { data: dataResponse, errors: errorsResponse, extensions } = response;
     //Reject promises with errors from query
     errorsResponse.forEach((errorResponse) => {
       Object.entries(errorResponse).forEach(([_key, val]) => {
@@ -6863,25 +6866,33 @@ class DataFetcher {
     });
     //Resolve promises with data from query
     dataResponse.forEach((data) => {
-      Object.entries(data).forEach(([key, val]) => {
-        var _a;
-        (((_a = watingRequestsById.get(key)) === null || _a === void 0 ? void 0 : _a.resolve) || Promise.resolve)(val);
+      Object.entries(data).forEach(async ([key, val]) => {
+        const waitingRequest = watingRequestsById.get(key);
+        await this.proccesGraphQLClientEvents(extensions, waitingRequest.request, waitingRequest.resolve, waitingRequest.reject);
+        ((waitingRequest === null || waitingRequest === void 0 ? void 0 : waitingRequest.resolve) || Promise.resolve)(val);
       });
     });
   }
-  async fecthGrapql(request) {
-    let res = undefined;
-    let dataResponse = [];
-    let errorsResponse = [];
-    let url = `${this.resolveURL() + this.GRAPHQL_PATH}`;
-    const responseExtensions = [];
-    if (window['mgeSession']) {
-      url += `?mgeSession=${window['mgeSession']}`;
+  buildGraphQlURL(quietMode) {
+    const mgeSession = window["mgeSession"];
+    let url = `${this.resolveURL() + DataFetcher.getGraphQLPath()}`;
+    if (mgeSession) {
+      url += `?mgeSession=${mgeSession}`;
+    }
+    if (quietMode) {
+      url += `${url.indexOf("?") > -1 ? "&" : "?"}quietMode=true`;
     }
-    DataFetcher.requestListener.forEach(listener => listener.onRequestStart({ url: url, requestBody: request }));
+    return url;
+  }
+  async fecthGraphQL(request, quietMode) {
+    const dataResponse = [];
+    const errorsResponse = [];
+    const responseExtensions = [];
+    const url = this.buildGraphQlURL(quietMode);
+    DataFetcher.requestListener.forEach(listener => listener.onRequestStart({ url, requestBody: request }));
     try {
-      res = await dist.batchRequests(url, request, { 'Content-Type': `application/json; charset=${window['SERVER_ENCODING'] || 'UTF-8'}` });
-      res.forEach((resItem, index) => {
+      const response = await dist.batchRequests(url, request, { 'Content-Type': `application/json; charset=${window['SERVER_ENCODING'] || 'UTF-8'}` });
+      response.forEach((resItem, index) => {
         var _a;
         if (((_a = resItem === null || resItem === void 0 ? void 0 : resItem.errors) === null || _a === void 0 ? void 0 : _a.length) > 0) {
           errorsResponse.push(resItem.errors.map((item) => this.normalizeErrorResponse(item, request, index)));
@@ -6896,7 +6907,7 @@ class DataFetcher {
     }
     catch (err) {
       if (!this.isHttpError(err)) {
-        res = err.response;
+        const res = err.response;
         const req = err.request;
         Object.entries(res).forEach(([key, val]) => {
           if (val.errors) {
@@ -6912,11 +6923,11 @@ class DataFetcher {
         });
       }
       else {
-        DataFetcher.requestListener.forEach(listener => listener.onRequestEnd({ url: url, requestBody: request }));
+        DataFetcher.requestListener.forEach(listener => listener.onRequestEnd({ url, requestBody: request }));
         throw new core.ErrorException("Falha de comunicação", err.message);
       }
     }
-    DataFetcher.requestListener.forEach(listener => listener.onRequestEnd({ url: url, requestBody: request }));
+    DataFetcher.requestListener.forEach(listener => listener.onRequestEnd({ url, requestBody: request }));
     return { data: dataResponse, errors: errorsResponse, extensions: responseExtensions };
   }
   isHttpError(err) {
@@ -6962,7 +6973,7 @@ DataFetcher.SERVICE_BROKER_STATUS = {
 };
 DataFetcher.clientEventsByID = new Map();
 class WaitingRequest {
-  constructor(req) {
+  constructor(req, quietMode) {
     this._resolve = () => { };
     this._reject = () => { };
     this._request = undefined;
@@ -6971,6 +6982,7 @@ class WaitingRequest {
       this._resolve = resolve;
       this._reject = reject;
     });
+    this._quietMode = quietMode;
   }
   get resolve() {
     return this._resolve;
@@ -6984,6 +6996,9 @@ class WaitingRequest {
   get request() {
     return this._request;
   }
+  get quietMode() {
+    return this._quietMode;
+  }
 }
 
 exports.DataFetcher = DataFetcher;

package/dist/cjs/PreloadManager-84466da6.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const core = require('@sankhyalabs/core');
+const utils = require('@sankhyalabs/ezui/dist/collection/components/ez-grid/utils');
+
+class ArrayRepository {
+  constructor(equalsFunction) {
+    this._list = [];
+    this._equalsFunction = equalsFunction;
+  }
+  async load(filterFunction, sortingFunction, offset, limit) {
+    let result = [].concat(this._list);
+    if (filterFunction != undefined) {
+      result = this._list.filter(item => filterFunction(item));
+    }
+    if (sortingFunction != undefined) {
+      result = result.sort(sortingFunction);
+    }
+    const count = result.length;
+    if (limit != undefined) {
+      const start = offset || 0;
+      const end = limit ? start + limit : result.length;
+      result = result.slice(start, end);
+    }
+    return Promise.resolve({ result, count });
+  }
+  async distict(itemProcessor) {
+    const processedItems = [];
+    let hasEmpty = false;
+    for (const item of this._list) {
+      const processedItem = itemProcessor(item);
+      if (processedItem == undefined) {
+        continue;
+      }
+      if (processedItem.value == undefined) {
+        hasEmpty = true;
+        continue;
+      }
+      processedItems.push(processedItem);
+    }
+    if (hasEmpty) {
+      processedItems.push({ key: "", value: null });
+    }
+    return Promise.resolve(new Map(processedItems.map(item => [item.key, item.value])));
+  }
+  async push(items) {
+    this._list.push(...items);
+  }
+  async clear() {
+    this._list = [];
+  }
+  async delete(items) {
+    this._list = this._list.filter(item => {
+      for (const removed of items) {
+        if (this._equalsFunction(item, removed)) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+  async update(items) {
+    this._list = this._list.map(existingItem => {
+      const newItem = items.find(newItem => this._equalsFunction(existingItem, newItem));
+      return newItem == undefined ? existingItem : newItem;
+    });
+  }
+  async insert(itemReference, items) {
+    const itemPosition = this._list.indexOf(itemReference);
+    if (itemPosition == -1) {
+      this._list.push(...items);
+      return;
+    }
+    this._list = this._list.slice(0, itemPosition).concat(items).concat(this._list.slice(itemPosition));
+  }
+  isOperating() {
+    return true;
+  }
+  async isEmpty() {
+    return Promise.resolve(this._list.length === 0);
+  }
+  async count() {
+    return Promise.resolve(this._list.length);
+  }
+}
+
+class PreloadManager {
+  static setLoadingStatus(dataUnit, loadingInProgress) {
+    this._loadingStatus.set(dataUnit.name, loadingInProgress);
+  }
+  static isCacheEnabled(_dataUnit) {
+    return true;
+  }
+  static cacheRecords(dataUnit, records, resetDatabase, loadingInProgress) {
+    PreloadManager.setLoadingStatus(dataUnit, loadingInProgress);
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      this.getRepository(dataUnit).push(records);
+    }
+    else {
+      if (resetDatabase) {
+        this._repositories.delete(dataUnit.name);
+      }
+    }
+  }
+  static getSortingFunction(dataUnit, sorting) {
+    if (sorting == undefined || sorting.length == 0) {
+      return undefined;
+    }
+    return (recordA, recordB) => {
+      for (const sort of sorting) {
+        const result = core.FieldComparator.compare(dataUnit.getField(sort.field), recordA, recordB, sort.mode === core.SortMode.ASC);
+        if (result != 0) {
+          return result;
+        }
+      }
+    };
+  }
+  static async getDistinct(dataUnit, fieldName) {
+    if (!PreloadManager.isCacheEnabled(dataUnit)) {
+      return Promise.resolve(utils.ColumnFilterManager.compileDistinct(fieldName, dataUnit));
+    }
+    let filterFunction;
+    const request = dataUnit.getLastLoadRequest();
+    if (request != undefined) {
+      const columnFilters = utils.ColumnFilterManager.getColumnFilters(request.filters, fieldName);
+      filterFunction = utils.ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values()));
+    }
+    return new Promise((accept, reject) => {
+      PreloadManager.getRepository(dataUnit).distict(record => {
+        if (filterFunction != undefined && !filterFunction(record)) {
+          return undefined;
+        }
+        const fieldValue = record[fieldName];
+        if (fieldValue == undefined) {
+          return { key: null, value: null };
+        }
+        const value = fieldValue.value != undefined ? fieldValue.value : fieldValue;
+        return { key: dataUnit.getFormattedValue(fieldName, fieldValue), value };
+      })
+        .then(result => {
+        if (result == undefined) {
+          accept(undefined);
+          return;
+        }
+        accept(Array.from(result.entries()).map(([label, value]) => ({ label, value, check: true })));
+      })
+        .catch(reason => reject(reason));
+    });
+  }
+  static async loadData(dataUnit, request, loadFromServer) {
+    try {
+      if (PreloadManager.isCacheEnabled(dataUnit)) {
+        let useCache = request.source === "EZ_GRID_LOADING_SOURCE" || request.source === core.DataUnit.CHANGING_PAGE_LOADING_SOURCE;
+        if (useCache) {
+          const isCacheEmpty = await PreloadManager.getRepository(dataUnit).isEmpty();
+          if (!isCacheEmpty) {
+            return PreloadManager.loadFromCache(dataUnit, request);
+          }
+        }
+        //Como não vamos aproveitar o cache, ele precisa ser limpo.
+        PreloadManager.getRepository(dataUnit).clear().catch(() => { });
+      }
+      return loadFromServer(dataUnit, request);
+    }
+    catch (error) {
+      console.error(error);
+      return Promise.reject(error);
+    }
+  }
+  static insertRecords(dataUnit, reference, records) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      PreloadManager.getRepository(dataUnit).insert(reference, records);
+    }
+  }
+  static updateRecords(dataUnit, records) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      PreloadManager.getRepository(dataUnit).update(records);
+    }
+  }
+  static removeRecords(dataUnit, records) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      PreloadManager.getRepository(dataUnit).delete(records);
+    }
+  }
+  static async countRecords(dataUnit) {
+    if (PreloadManager.isCacheEnabled(dataUnit)) {
+      return PreloadManager.getRepository(dataUnit).count();
+    }
+    return Promise.resolve(0);
+  }
+  static getRepository(dataUnit) {
+    const name = dataUnit.name;
+    if (!PreloadManager._repositories.has(name)) {
+      PreloadManager._repositories.set(name, new ArrayRepository((recordA, recordB) => recordA.__record__id__ === recordB.__record__id__));
+    }
+    return PreloadManager._repositories.get(name);
+  }
+  static async loadFromCache(dataUnit, request) {
+    return new Promise((accept, reject) => {
+      const columnFilters = utils.ColumnFilterManager.getColumnFilters(request.filters, "");
+      const { limit, offset, sort } = request;
+      PreloadManager.getRepository(dataUnit)
+        .load(utils.ColumnFilterManager.getFilterFunction(dataUnit, Array.from(columnFilters.values())), PreloadManager.getSortingFunction(dataUnit, sort), offset, limit)
+        .then(loadResult => {
+        const stillLoading = PreloadManager._loadingStatus.get(dataUnit.name);
+        const { count, result: records } = loadResult;
+        const firstRecord = count == 0 ? 0 : offset + 1;
+        const lastRecord = offset + Math.min(records.length, limit);
+        const currentPage = offset / limit;
+        const paginationInfo = {
+          count, currentPage, firstRecord, lastRecord,
+          hasMore: stillLoading || (lastRecord < count),
+          total: stillLoading ? undefined : count
+        };
+        accept({ records, paginationInfo });
+      })
+        .catch(reason => reject(reason));
+    });
+  }
+}
+PreloadManager._repositories = new Map();
+PreloadManager._loadingStatus = new Map();
+
+exports.PreloadManager = PreloadManager;

package/dist/cjs/{SnkFormConfigManager-12cd719b.js → SnkFormConfigManager-29101e20.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-const ConfigStorage = require('./ConfigStorage-c26705cc.js');
+const ConfigStorage = require('./ConfigStorage-c15716fd.js');
 const core = require('@sankhyalabs/core');
-const formConfigFetcher = require('./form-config-fetcher-037d16de.js');
+const formConfigFetcher = require('./form-config-fetcher-17775a75.js');
 
 class SnkFormConfigManager {
   constructor(configName, resourceID, onConfigChange) {

package/dist/cjs/{SnkMessageBuilder-d0abb63d.js → SnkMessageBuilder-0202c090.js}

@@ -174,6 +174,15 @@ const fileViewerMessages = {
   }
 };
 
+const snkAttachMessages$1 = {
+  newVersionPopup: {
+    title: "Boas vindas à nova interface da tela {{screenName}}",
+    info: "Com uma jornada mais moderna, simples e intuitiva, a performance aprimorada da nova interface impulsionará a sua produtividade.",
+    okButton: "Quero experimentar!",
+    cancelButton: "Voltar à interface anterior",
+  }
+};
+
 const snkConfigOptionsMessages = {
   label: {
     nameField: "Nome do Campo *",
@@ -507,6 +516,7 @@ const snkPrintSelectorMessages = {
 class SnkMessageBuilder {
   constructor(domainName) {
     this._defaults = {
+      snkApplication: snkAttachMessages$1,
       snkDataUnit: snkDataUnitMessages,
       snkFormConfig: snkFormConfigMessages,
       snkConfigOptions: snkConfigOptionsMessages,
@@ -529,7 +539,7 @@ class SnkMessageBuilder {
       snkPersonalizedFilter: snkPersonalizedFilterMessages,
       snkEntityList: snkEntityListMessages,
       snkActionsButton: snkActionsButtonMessages,
-      snkPrintSelector: snkPrintSelectorMessages
+      snkPrintSelector: snkPrintSelectorMessages,
     };
     this._currentOperation = exports.OperationMap.CLEAN;
     this._domainName = domainName;
@@ -576,10 +586,12 @@ class SnkMessageBuilder {
     return this.postProcess(msg, params);
   }
   getDomainMessages() {
-    if (this._domainName == undefined) {
+    if (!this._appMessages)
+      return undefined;
+    if (!this._domainName) {
       return this._appMessages['Global'] || this._appMessages;
     }
-    return (this._appMessages == undefined ? undefined : this._appMessages[this._domainName]);
+    return this._appMessages[this._domainName];
   }
   resolveMessage(keys, object) {
     if (object == undefined) {

package/dist/cjs/{SnkMultiSelectionListDataSource-804ff4c7.js → SnkMultiSelectionListDataSource-ba5838c2.js}

@@ -1,6 +1,12 @@
 'use strict';
 
 const core = require('@sankhyalabs/core');
+const InMemoryFilterColumnDataSource = require('@sankhyalabs/ezui/dist/collection/components/ez-grid/utils/InMemoryFilterColumnDataSource');
+const PreloadManager = require('./PreloadManager-84466da6.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const InMemoryFilterColumnDataSource__default = /*#__PURE__*/_interopDefaultLegacy(InMemoryFilterColumnDataSource);
 
 class SnkMultiSelectionListDataSource {
   setDataUnit(dataUnit) {
@@ -16,6 +22,12 @@ class SnkMultiSelectionListDataSource {
     }
     return String(this._dataUnit.getFormattedValue(fieldName, value));
   }
+  async getStaticOptions(fieldName) {
+    if (fieldName == undefined) {
+      return Promise.resolve(undefined);
+    }
+    return Promise.resolve(await PreloadManager.PreloadManager.getDistinct(this._dataUnit, fieldName));
+  }
   fetchData(filterTerm, fieldName) {
     return new Promise(resolve => {
       this._application.executeSelectDistinct(this._dataUnit, fieldName, filterTerm).then(result => {
@@ -29,6 +41,9 @@ class SnkMultiSelectionListDataSource {
       });
     });
   }
+  sortItems(fieldName, items) {
+    return InMemoryFilterColumnDataSource__default['default'].defaultSorterMultSelectionOption(this._dataUnit, fieldName, items);
+  }
 }
 
 exports.SnkMultiSelectionListDataSource = SnkMultiSelectionListDataSource;

package/dist/cjs/{auth-fetcher-8ba4a15e.js → auth-fetcher-555ff856.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 const core = require('@sankhyalabs/core');
-const formConfigFetcher = require('./form-config-fetcher-037d16de.js');
+const formConfigFetcher = require('./form-config-fetcher-17775a75.js');
 
 class AuthFetcher extends formConfigFetcher.ResourceFetcher {
   getData(resourceID) {