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

package/dist/collection/lib/dataUnit/InMemoryLoader.js

@@ -0,0 +1,134 @@
+import { ChangeOperation, DataType, DataUnit, SortMode, StringUtils, } from '@sankhyalabs/core';
+import { DISTINCT_FILTER_NAME_PREFIX } from "@sankhyalabs/ezui/dist/collection/utils/constants";
+export default class InMemoryLoader {
+  constructor(metadata, records) {
+    this.records = records || [];
+    this.metadata = metadata;
+    this._dataUnit = new DataUnit(InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME);
+    this._dataUnit.metadataLoader = () => this.metadaLoader();
+    this._dataUnit.dataLoader = (dataUnit, request) => this.dataLoader(dataUnit, request);
+    this._dataUnit.saveLoader = (_dataUnit, changes) => this.saveLoader(_dataUnit, changes);
+    this._dataUnit.removeLoader = (_dataUnit, recordIds) => this.removeLoader(_dataUnit, recordIds);
+    this.dataUnit.loadMetadata().then(() => this.dataUnit.loadData());
+  }
+  get dataUnit() {
+    return this._dataUnit;
+  }
+  get records() {
+    return this._records;
+  }
+  set records(records) {
+    this._records = records === null || records === void 0 ? void 0 : records.map(record => {
+      if (!record["__record__id__"]) {
+        record["__record__id__"] = this.generateUniqueId();
+      }
+      return record;
+    });
+    if (this._dataUnit) {
+      this._dataUnit.records = [...this._records];
+    }
+  }
+  get metadata() {
+    return this._metadata;
+  }
+  set metadata(metadata) {
+    this._metadata = metadata;
+    if (this._dataUnit) {
+      this._dataUnit.metadata = this._metadata;
+    }
+  }
+  generateUniqueId() {
+    return StringUtils.generateUUID();
+  }
+  metadaLoader() {
+    return Promise.resolve(this._metadata);
+  }
+  dataLoader(dataUnit, request) {
+    const filters = this.getColumnFilters(dataUnit);
+    let records = this.applyFilters(filters);
+    if (request.sort) {
+      request.sort.forEach(sort => {
+        records = records.sort((recordA, recordB) => {
+          const fieldA = recordA[sort.field];
+          const fieldB = recordB[sort.field];
+          const sortFn = this.getSortFn(sort.dataType);
+          return sortFn(fieldA, fieldB) * (sort.mode == SortMode.ASC ? 1 : -1);
+        });
+      });
+    }
+    return Promise.resolve({ records: records });
+  }
+  applyFilters(filters) {
+    let records = [...this._records];
+    filters.forEach(filter => {
+      records = records.filter(record => { var _a; return filter.values.includes((_a = record[filter.column]) === null || _a === void 0 ? void 0 : _a.toString()); });
+    });
+    return records;
+  }
+  getColumnFilters(dataUnit) {
+    var _a, _b;
+    const allFilters = (_a = dataUnit.getFilters()) !== null && _a !== void 0 ? _a : [];
+    const columnFilters = (_b = allFilters.filter(filter => { var _a; return (_a = filter.name) === null || _a === void 0 ? void 0 : _a.includes(DISTINCT_FILTER_NAME_PREFIX); })) !== null && _b !== void 0 ? _b : [];
+    return columnFilters.map(filter => {
+      var _a, _b;
+      return {
+        column: (_b = (_a = filter.name) === null || _a === void 0 ? void 0 : _a.replace(DISTINCT_FILTER_NAME_PREFIX, "")) !== null && _b !== void 0 ? _b : "",
+        values: filter.params.map(param => param.value),
+      };
+    });
+  }
+  getSortFn(type) {
+    switch (type) {
+      case DataType.NUMBER:
+        return this.sortNumber;
+      case DataType.DATE:
+        return this.sortDate;
+      case DataType.OBJECT:
+        return this.sortObject;
+      default:
+        return StringUtils.compare;
+    }
+  }
+  sortObject(a, b) {
+    return StringUtils.compare(a === null || a === void 0 ? void 0 : a["label"], b === null || b === void 0 ? void 0 : b["label"]);
+  }
+  sortNumber(a, b) {
+    return a - b;
+  }
+  sortDate(a, b) {
+    let timeA = a.getTime(), timeB = b.getTime();
+    return timeA === timeB ? 0 : (timeA < timeB ? -1 : 1);
+  }
+  saveLoader(_dataUnit, changes) {
+    return new Promise((resolve) => {
+      let dataUnitRecords = [];
+      changes.forEach(change => {
+        let { record, updatingFields, operation } = change;
+        let isAdd = false;
+        if (operation === ChangeOperation.INSERT ||
+          operation === ChangeOperation.COPY) {
+          record["__old__id__"] = record["__record__id__"];
+          record["__record__id__"] = this.generateUniqueId();
+          isAdd = true;
+        }
+        const changedRecord = Object.assign(Object.assign({}, record), updatingFields);
+        if (isAdd) {
+          this.records.push(changedRecord);
+        }
+        else {
+          const recordIndex = this.records.findIndex(r => r["__record__id__"] == changedRecord["__record__id__"]);
+          this.records[recordIndex] = changedRecord;
+        }
+        dataUnitRecords.push(changedRecord);
+      });
+      resolve(dataUnitRecords);
+    });
+  }
+  removeLoader(_dataUnit, recordIds) {
+    return new Promise((resolve) => {
+      this._records = this._records.filter(record => !recordIds.includes(record["__record__id__"]));
+      resolve(recordIds);
+    });
+  }
+}
+InMemoryLoader.IN_MEMORY_DATA_UNIT_NAME = "InMemoryDataUnit";

package/dist/collection/lib/http/data-fetcher/DataFetcher.js

@@ -0,0 +1,408 @@
+import { ApplicationContext, ErrorException, ObjectUtils, WarningException } from '@sankhyalabs/core';
+import { batchRequests } from 'graphql-request';
+import UrlUtils from "../../../lib/utils/urlutils";
+import { StringUtils } from '@sankhyalabs/core';
+import { ServiceBrokerRecaller } from './recaller/ServiceBrokerRecaller';
+import { GraphQLRecaller } from './recaller/GraphQLRecaller';
+import { PrintUtils } from '../../utils/PrintUtils';
+export class DataFetcher {
+  constructor() {
+    this.GRAPHQL_PATH = "/mgefin-bff/graphql";
+    this.watingRequestsById = new Map();
+  }
+  static get() {
+    if (!DataFetcher.instance) {
+      DataFetcher.instance = new DataFetcher();
+      const application = document.querySelector(this.appTagName);
+      if (application === null) {
+        DataFetcher.instance.resume();
+      }
+      else {
+        application.addEventListener('applicationLoading', () => DataFetcher.instance.pause());
+        application.addEventListener('applicationLoaded', () => DataFetcher.instance.resume());
+      }
+    }
+    this.instance.application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
+    return this.instance;
+  }
+  static addRequestListener(listener) {
+    const index = DataFetcher.requestListener.indexOf(listener);
+    if (index < 0) {
+      DataFetcher.requestListener.push(listener);
+    }
+  }
+  static removeRequestListener(listener) {
+    const index = DataFetcher.requestListener.indexOf(listener);
+    if (index > -1) {
+      DataFetcher.requestListener.splice(index, 1);
+    }
+  }
+  processGraphQlErrorInfo(errors) {
+    var _a, _b;
+    const POSITION_ERROR_INFO = 0;
+    const errorTitle = "Falha detectada";
+    const error = errors[POSITION_ERROR_INFO];
+    if (error.length > 0) { //As informações do erro vem no primeiro indice de um array
+      const errorInfo = error[POSITION_ERROR_INFO];
+      const errorMessage = (errorInfo === null || errorInfo === void 0 ? void 0 : errorInfo.message) ? errorInfo === null || errorInfo === void 0 ? void 0 : errorInfo.message : "Não há mensagem de erro";
+      const errorLevel = ((_a = errorInfo === null || errorInfo === void 0 ? void 0 : errorInfo.extensions) === null || _a === void 0 ? void 0 : _a.level) ? errorInfo.extensions.level : "ERROR";
+      const errorCode = ((_b = errorInfo === null || errorInfo === void 0 ? void 0 : errorInfo.extensions) === null || _b === void 0 ? void 0 : _b.code) ? errorInfo.extensions.code : "";
+      switch (errorLevel) {
+        case "WARNING":
+          return new WarningException(errorTitle, errorMessage, errorCode);
+        default:
+          return new ErrorException(errorTitle, errorMessage, errorCode);
+      }
+    }
+    else {
+      return new ErrorException(errorTitle, "Não há informações sobre o erro");
+    }
+  }
+  processServiceBrokerErrorInfo(serviceBrokerResponse) {
+    const title = "Falha detectada";
+    let { statusMessage, tsError } = serviceBrokerResponse || {};
+    if (!statusMessage) {
+      statusMessage = "Não há informações sobre o erro";
+    }
+    let tsErrorCode, tsErrorLevel;
+    if (tsError) {
+      tsErrorCode = tsError.tsErrorCode;
+      tsErrorLevel = tsError.tsErrorLevel;
+    }
+    if (tsErrorLevel === "WARNING") {
+      return new WarningException(title, statusMessage, tsErrorCode);
+    }
+    return new ErrorException(title, statusMessage, tsErrorCode);
+  }
+  async callGraphQL(req) {
+    var _a;
+    const reqKey = this.getReqKey(req);
+    req.queryID = reqKey;
+    req.values.queryID = reqKey;
+    if (DataFetcher.clientEventsByID) {
+      req.values.registeredEventListeners = [];
+      for (let [key] of DataFetcher.clientEventsByID) {
+        req.values.registeredEventListeners.push(key);
+      }
+    }
+    if (this.ready) {
+      return new Promise(async (resolve, reject) => {
+        let query = this.getQueryTemplate(req);
+        const res = await this.fecthGrapql([{ document: query, variables: req.values }]);
+        if (res.errors.length > 0) {
+          if (!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);
+        }
+      });
+    }
+    else {
+      if (!this.watingRequestsById.has(reqKey)) {
+        this.watingRequestsById.set(reqKey, new WaitingRequest(req));
+      }
+      return (_a = this.getWatingRequest(reqKey)) === null || _a === void 0 ? void 0 : _a.promise;
+    }
+  }
+  resolveURL() {
+    return UrlUtils.getUrlBase();
+  }
+  proccesGraphQLClientEvents(extensions, originalRequest, resolve, reject) {
+    if (extensions == undefined) {
+      return false;
+    }
+    for (const idx in extensions) {
+      const { clientEvents } = extensions[idx];
+      if (!clientEvents) {
+        return false;
+      }
+      for (const id in clientEvents) {
+        if (!DataFetcher.hasClientEvent(id)) {
+          console.warn(`Client event ${id} not registered`);
+          throw new 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));
+        });
+      }
+      return Object.keys(clientEvents).length > 0;
+    }
+    return false;
+  }
+  proccessServiceBorkerClientEvents(clientEvents, serviceName, payloadJson, accept, reject) {
+    if (!(clientEvents === null || clientEvents === void 0 ? void 0 : clientEvents.length)) {
+      return;
+    }
+    clientEvents.forEach(clientEvent => {
+      if (DataFetcher.hasClientEvent(clientEvent.id)) {
+        var handlers = DataFetcher.clientEventsByID.get(clientEvent.id);
+        handlers.forEach(handler => {
+          handler({ id: clientEvent.id, content: clientEvent }, new ServiceBrokerRecaller(serviceName, payloadJson, accept, reject));
+        });
+      }
+    });
+  }
+  processPrinting(payload) {
+    if ((payload === null || payload === void 0 ? void 0 : payload.pendingPrinting) === 'true') {
+      PrintUtils.getInstance().processPendingPrinting(payload === null || payload === void 0 ? void 0 : payload.transactionId);
+    }
+    if ('localPrintings' in payload) {
+      PrintUtils.getInstance().processLocalPrinting(payload === null || payload === void 0 ? void 0 : payload.localPrintings);
+    }
+  }
+  getContext(module) {
+    var _a;
+    const urlParams = UrlUtils.getQueryParams(location.search);
+    return {
+      baseUrl: `${this.resolveURL()}/${module}/service.sbr`,
+      appName: "SankhyaBlocks",
+      mgeSession: `${window['mgeSession'] || urlParams.get("mgeSession")}`,
+      globalID: "85C0093DFA240EAB699B4E47A10215BD",
+      resourceID: (window["resourceID"] || ((_a = window["workspace"]) === null || _a === void 0 ? void 0 : _a.resourceID))
+    };
+  }
+  async callServiceBroker(serviceName, payload, options) {
+    return new Promise((accept, reject) => {
+      const parts = serviceName.split("@");
+      const [module, name] = parts.length === 2 ? parts : ['mge', serviceName];
+      const ctx = this.getContext(module);
+      let url = `${ctx.baseUrl}?serviceName=${name}&counter=21&application=${ctx.appName}&outputType=json&preventTransform=false&mgeSession=${ctx.mgeSession}&resourceID=${ctx.resourceID}&globalID=${ctx.globalID}&allowConcurrentCalls=true`;
+      url = this.addUrlParams(options, url);
+      document.cookie = `JSESSIONID=${ctx.mgeSession};`;
+      const http = new XMLHttpRequest();
+      var payloadJson = {};
+      if ('string' == typeof payload) {
+        payload = ObjectUtils.stringToObject(payload);
+      }
+      if (!payload.hasOwnProperty('requestBody')) {
+        payloadJson['requestBody'] = payload;
+      }
+      else {
+        payloadJson = payload;
+      }
+      for (let [key] of DataFetcher.clientEventsByID) {
+        if (!payloadJson['requestBody'].hasOwnProperty('clientEventList')) {
+          payloadJson['requestBody']['clientEventList'] = {
+            clientEvent: []
+          };
+        }
+        payloadJson['requestBody']['clientEventList'].clientEvent.push({ $: key });
+      }
+      DataFetcher.requestListener.forEach(listener => listener.onRequestStart({ url: url, requestBody: payload }));
+      http.open("POST", url, true);
+      http.withCredentials = true;
+      http.send(ObjectUtils.objectToString(payloadJson));
+      http.onreadystatechange = () => {
+        var _a;
+        if (http.readyState == 4 && http.status == 200) {
+          try {
+            const jsonResp = JSON.parse(http.responseText);
+            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 {
+              accept(jsonResp.responseBody);
+              if (jsonResp.status == DataFetcher.SERVICE_BROKER_STATUS.INFO) {
+                (_a = this.application) === null || _a === void 0 ? void 0 : _a.info(jsonResp.statusMessage);
+              }
+            }
+            this.proccessServiceBorkerClientEvents(jsonResp === null || jsonResp === void 0 ? void 0 : jsonResp.clientEvents, serviceName, payloadJson, accept, reject);
+            this.processPrinting(jsonResp);
+          }
+          catch (err) {
+            console.warn(`Erro ao executar serviço: ${err}`);
+            reject(new ErrorException(`Erro ao executar serviço`, err));
+          }
+        }
+        else if (http.readyState == 4 && http.status != 200) {
+          reject(new ErrorException(`Erro ao executar serviço: ${serviceName}`, http.responseText));
+        }
+        DataFetcher.requestListener.forEach(listener => listener.onRequestEnd({ url: url, requestBody: payload }));
+      };
+    });
+  }
+  addUrlParams(options, url) {
+    const params = options === null || options === void 0 ? void 0 : options.urlParams;
+    if (!params || Object.keys(params).length === 0) {
+      return url;
+    }
+    url += '&';
+    for (const key in params) {
+      if (params.hasOwnProperty(key)) {
+        url += `${key}=${params[key]}`;
+      }
+    }
+    return url;
+  }
+  isServiceBrokerError(response) {
+    return !response.hasOwnProperty('status') ||
+      response.status == DataFetcher.SERVICE_BROKER_STATUS.ERROR ||
+      response.status == DataFetcher.SERVICE_BROKER_STATUS.TIMEOUT;
+  }
+  getReqKey(req) {
+    return window.btoa(StringUtils.hashCode(`${req.query}${JSON.stringify(req.values || "")}`)).replace(/=/g, "");
+  }
+  getQueryTemplate(re) {
+    return (re.query || "").replaceAll("$queryAlias$", re.queryID);
+  }
+  getWatingRequest(reqID) {
+    return this.watingRequestsById.get(reqID);
+  }
+  pause() {
+    this.ready = false;
+  }
+  async resume() {
+    this.ready = true;
+    if (this.watingRequestsById.size > 0) {
+      const requestsBatch = [];
+      this.watingRequestsById.forEach(async (waitingReq) => {
+        let query = this.getQueryTemplate(waitingReq.request);
+        requestsBatch.push({ document: query, variables: Object.assign({}, waitingReq.request.values) });
+      });
+      let res = undefined;
+      let dataResponse = [];
+      let errorsResponse = [];
+      res = await this.fecthGrapql(requestsBatch);
+      dataResponse = res.data;
+      errorsResponse = res.errors;
+      //Reject promises with errors from query
+      errorsResponse.forEach((errorResponse) => {
+        Object.entries(errorResponse).forEach(([_key, val]) => {
+          var _a;
+          (((_a = this.getWatingRequest(val.request.variables[val.index].queryID)) === null || _a === void 0 ? void 0 : _a.reject) || Promise.reject)(new ErrorException("Falha detectada", val.message));
+        });
+      });
+      //Resolve promises with data from query
+      dataResponse.forEach((data) => {
+        Object.entries(data).forEach(([key, val]) => {
+          var _a;
+          (((_a = this.getWatingRequest(key)) === null || _a === void 0 ? void 0 : _a.resolve) || Promise.resolve)(val);
+        });
+      });
+      this.watingRequestsById.clear();
+    }
+  }
+  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']}`;
+    }
+    DataFetcher.requestListener.forEach(listener => listener.onRequestStart({ url: url, requestBody: request }));
+    try {
+      res = await batchRequests(url, request, { 'Content-Type': `application/json; charset=${window['SERVER_ENCODING'] || 'UTF-8'}` });
+      res.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)));
+        }
+        else {
+          dataResponse.push(resItem.data);
+        }
+        if (resItem.extensions) {
+          responseExtensions.push(resItem.extensions);
+        }
+      });
+    }
+    catch (err) {
+      if (!this.isHttpError(err)) {
+        res = err.response;
+        const req = err.request;
+        Object.entries(res).forEach(([key, val]) => {
+          if (val.errors) {
+            errorsResponse.push(val.errors.map((item) => {
+              item.request = req;
+              item.index = Number(key);
+              return item;
+            }));
+          }
+          else if (val.data) {
+            dataResponse.push(val.data);
+          }
+        });
+      }
+      else {
+        DataFetcher.requestListener.forEach(listener => listener.onRequestEnd({ url: url, requestBody: request }));
+        throw new ErrorException("Falha de comunicação", err.message);
+      }
+    }
+    DataFetcher.requestListener.forEach(listener => listener.onRequestEnd({ url: url, requestBody: request }));
+    return { data: dataResponse, errors: errorsResponse, extensions: responseExtensions };
+  }
+  isHttpError(err) {
+    var _a;
+    return !err.response && !err.request || (((_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.status) >= 300);
+  }
+  normalizeErrorResponse(error, requests, requestIndex) {
+    const req = Object.assign({}, requests[requestIndex]);
+    const { variables } = req;
+    req.variables = [];
+    req.variables[requestIndex] = variables;
+    error.request = req;
+    error.index = Number(requestIndex);
+    return error;
+  }
+  static addClientEvent(eventID, handler) {
+    let clientEvent = DataFetcher.clientEventsByID.get(eventID);
+    if (clientEvent != undefined) {
+      const hasItem = clientEvent.some((item) => item.toString() === handler.toString());
+      if (hasItem)
+        return;
+      clientEvent.push(handler);
+    }
+    else {
+      DataFetcher.clientEventsByID.set(eventID, [handler]);
+    }
+  }
+  static hasClientEvent(eventID) {
+    return DataFetcher.clientEventsByID.has(eventID);
+  }
+  static removeClientEvent(eventID) {
+    return DataFetcher.clientEventsByID.delete(eventID);
+  }
+}
+DataFetcher.appTagName = "snk-application";
+DataFetcher.requestListener = [];
+DataFetcher.SERVICE_BROKER_STATUS = {
+  ERROR: 0,
+  INFO: 2,
+  OK: 1,
+  TIMEOUT: 3,
+  SERVICE_CANCELED: 4
+};
+DataFetcher.clientEventsByID = new Map();
+class WaitingRequest {
+  constructor(req) {
+    this._resolve = () => { };
+    this._reject = () => { };
+    this._request = undefined;
+    this._request = req;
+    this._promisse = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get resolve() {
+    return this._resolve;
+  }
+  get reject() {
+    return this._reject;
+  }
+  get promise() {
+    return this._promisse;
+  }
+  get request() {
+    return this._request;
+  }
+}

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

@@ -0,0 +1,23 @@
+import { gql } from "graphql-request";
+import { DataFetcher } from "../DataFetcher";
+export default class ApplicationConfigFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this.templateByQuery.set("getResource", gql `query($name: String!) {
+            $queryAlias$: getResource(name: $name){
+              name
+              resource
+            }
+        }`);
+  }
+  getResource(name, resourceID) {
+    const completPath = `cfg://app/${resourceID}/${name}`;
+    return DataFetcher.get().callGraphQL({
+      values: { name: completPath },
+      query: this.templateByQuery.get("getResource"),
+    });
+  }
+}