@sankhyalabs/sankhyablocks 8.7.0 → 8.8.0-dev.2

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

@@ -0,0 +1,131 @@
+import { StringUtils, UserInterface } from "@sankhyalabs/core";
+import { DataFetcher } from "../../../DataFetcher";
+import DataUnitFetcher from "../dataunit-fetcher";
+import InMemoryLoader from "../../../../../dataUnit/InMemoryLoader";
+export class DatasetStrategy {
+  canSlice() {
+    return false;
+  }
+  async load(dataUnit, request, loadingInfo) {
+    if (dataUnit.metadata == undefined) {
+      return Promise.resolve({ records: [], loadingInfo });
+    }
+    try {
+      const fields = this.getFieldsList(dataUnit);
+      const serviceName = "DatasetSP.loadRecords";
+      const requestBody = this.buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo);
+      const { result: responseRecords, pagerID: pagerId } = await DataFetcher.get().callServiceBroker(serviceName, requestBody);
+      const records = this.processRecords(dataUnit, fields, responseRecords);
+      const loadingInProgress = pagerId != undefined;
+      const count = loadingInfo.count + records.length;
+      return Promise.resolve({
+        records,
+        loadingInfo: Object.assign(Object.assign({}, loadingInfo), { pagerId,
+          loadingInProgress, total: loadingInProgress ? undefined : count, count })
+      });
+    }
+    catch (error) {
+      console.error(error);
+      return Promise.reject(error);
+    }
+  }
+  getFieldsList(dataUnit) {
+    let fields = ["__record__id__", "__record__label__"];
+    dataUnit.metadata.fields.forEach(descriptor => {
+      fields = fields.concat(this.getFieldNames(descriptor));
+    });
+    return fields;
+  }
+  getFieldNames(descriptor) {
+    const descriptionField = this.getSearchDescriptionField(descriptor);
+    if (descriptionField == undefined) {
+      return descriptor.name;
+    }
+    return [descriptor.name, descriptionField];
+  }
+  buildRequestBody(serviceName, fields, dataUnit, request, loadingInfo) {
+    const dataSetID = dataUnit.dataUnitId;
+    const dataUnitName = dataUnit.name;
+    const entityName = DataUnitFetcher.parseDataUnitName(dataUnitName).entityName;
+    const requestBody = {
+      serviceName,
+      requestBody: {
+        dataSetID,
+        fields,
+        entityName,
+        pageNumber: loadingInfo.pageNumber,
+        totalRecordsCount: loadingInfo.count,
+        pagerID: loadingInfo.pagerId,
+        standAlone: false,
+        standAloneFieldsMD: {
+          __record__id__: { "fieldType": "S", "userType": "P" },
+          __record__label__: { "fieldType": "S", "userType": "P" }
+        },
+        tryJoinedFields: true,
+        parallelLoader: true,
+        crudListener: "br.com.sankhya.modelcore.dataset.DataUnitDatasetAdapter",
+        txProperties: this.getTxProperties(dataUnitName, request),
+        useDefaultRowsLimit: false
+      }
+    };
+    return JSON.stringify(requestBody);
+  }
+  getTxProperties(dataUnitName, request) {
+    const txProperties = {
+      "__DATA_UNIT_ADAPTER__[dataUnitName]": dataUnitName
+    };
+    const serverSideFilters = request.filters.filter(filter => !filter.name.startsWith("FILTRO_COLUNA_"));
+    if (serverSideFilters.length !== 0) {
+      txProperties["__DATA_UNIT_ADAPTER__[criteria]"] = JSON.stringify(serverSideFilters);
+    }
+    const sorting = request.sort;
+    if (sorting != undefined && sorting.length !== 0) {
+      txProperties["__DATA_UNIT_ADAPTER__[sorting]"] = JSON.stringify(sorting);
+    }
+    return txProperties;
+  }
+  processRecords(dataUnit, fields, responseRecords) {
+    return responseRecords.map((dataFrame) => {
+      const duRecord = {
+        __record__id__: dataFrame[0],
+        __record__label__: dataFrame[1]
+      };
+      dataUnit.metadata.fields.forEach(fieldDescriptor => {
+        duRecord[fieldDescriptor.name] = this.buildFieldValue(fieldDescriptor, fields, dataFrame);
+      });
+      return duRecord;
+    });
+  }
+  buildFieldValue(descriptor, allFields, dataFrame) {
+    const fieldIndex = allFields.indexOf(descriptor.name);
+    if (fieldIndex < 0) {
+      return null;
+    }
+    const strValue = dataFrame[fieldIndex];
+    if (StringUtils.isEmpty(strValue)) {
+      return null;
+    }
+    const descriptionField = this.getSearchDescriptionField(descriptor);
+    if (descriptionField != undefined) {
+      const descriptionFieldIndex = allFields.indexOf(descriptionField);
+      if (descriptionFieldIndex >= 0) {
+        return { value: strValue, label: dataFrame[descriptionFieldIndex] };
+      }
+    }
+    if (descriptor.userInterface === UserInterface.SEARCH) {
+      //Se não tem um campo de descrição (código acima)
+      //Mas é um search, tentamos parsear um numero...
+      return isNaN(Number(strValue)) ? strValue : Number(strValue);
+    }
+    return InMemoryLoader.getConvertedValue(descriptor, strValue);
+  }
+  getSearchDescriptionField(descriptor) {
+    if (descriptor.userInterface === UserInterface.SEARCH) {
+      const { ENTITYNAME, mergedFrom, DESCRIPTIONFIELD } = descriptor.properties;
+      if (!StringUtils.isEmpty(DESCRIPTIONFIELD)) {
+        return mergedFrom != undefined ? `${mergedFrom}.${ENTITYNAME}.${DESCRIPTIONFIELD}` : `${ENTITYNAME}.${DESCRIPTIONFIELD}`;
+      }
+    }
+    return undefined;
+  }
+}

package/dist/collection/lib/index.js

@@ -5,7 +5,7 @@ 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 { default as DataUnitFetcher } from './http/data-fetcher/fetchers/dataunit-fetcher';
+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';
 export { default as GridConfigFetcher } from './http/data-fetcher/fetchers/grid-config-fetcher';

package/dist/components/DataFetcher.js

@@ -6541,11 +6541,10 @@ class DataFetcher {
       }
     }
     this.instance.application = ApplicationContext.getContextValue("__SNK__APPLICATION__");
-    this.instance.graphqlPath = `/${this.instance.application.getModuleName()}/graphql`;
     return this.instance;
   }
   static getGraphQLPath() {
-    if (StringUtils.isEmpty(this.instance.graphqlPath)) {
+    if (StringUtils.isEmpty(this.instance.graphqlPath) && this.instance.application != undefined) {
       this.instance.graphqlPath = `/${this.instance.application.getModuleName()}/graphql`;
     }
     return this.instance.graphqlPath;
@@ -6599,7 +6598,7 @@ class DataFetcher {
     }
     return new ErrorException(title, statusMessage, tsErrorCode);
   }
-  async callGraphQL(req) {
+  async callGraphQL(req, quietMode = false) {
     var _a;
     if (this.ready) {
       this.pause();
@@ -6617,7 +6616,7 @@ 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.fecthGrapql([{ 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)) {
             const error = this.processGraphQlErrorInfo(res.errors);
@@ -6632,7 +6631,7 @@ class DataFetcher {
     }
     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;
     }
@@ -6848,14 +6847,16 @@ class DataFetcher {
   }
   async executePendingRequest(watingRequestsById) {
     const requestsBatch = [];
+    let quietMode = true;
     watingRequestsById.forEach(async (waitingReq) => {
       let 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);
+    res = await this.fecthGrapql(requestsBatch, quietMode);
     dataResponse = res.data;
     errorsResponse = res.errors;
     //Reject promises with errors from query
@@ -6873,14 +6874,18 @@ class DataFetcher {
       });
     });
   }
-  async fecthGrapql(request) {
+  async fecthGrapql(request, quietMode) {
     let res = undefined;
     let dataResponse = [];
     let errorsResponse = [];
     let url = `${this.resolveURL() + DataFetcher.getGraphQLPath()}`;
     const responseExtensions = [];
-    if (window['mgeSession']) {
-      url += `?mgeSession=${window['mgeSession']}`;
+    const mgeSession = window["mgeSession"];
+    if (mgeSession != undefined) {
+      url += `?mgeSession=${mgeSession}`;
+    }
+    if (quietMode) {
+      url += `${url.indexOf("?") > -1 ? "&" : "?"}quietMode=true`;
     }
     DataFetcher.requestListener.forEach(listener => listener.onRequestStart({ url: url, requestBody: request }));
     try {
@@ -6966,7 +6971,7 @@ DataFetcher.SERVICE_BROKER_STATUS = {
 };
 DataFetcher.clientEventsByID = new Map();
 class WaitingRequest {
-  constructor(req) {
+  constructor(req, quietMode) {
     this._resolve = () => { };
     this._reject = () => { };
     this._request = undefined;
@@ -6975,6 +6980,7 @@ class WaitingRequest {
       this._resolve = resolve;
       this._reject = reject;
     });
+    this._quietMode = quietMode;
   }
   get resolve() {
     return this._resolve;
@@ -6988,6 +6994,9 @@ class WaitingRequest {
   get request() {
     return this._request;
   }
+  get quietMode() {
+    return this._quietMode;
+  }
 }
 
 export { DataFetcher as D, UrlUtils as U, dist as d };

package/dist/components/SnkMultiSelectionListDataSource.js

@@ -1,4 +1,5 @@
 import { UserInterface, DateUtils } from '@sankhyalabs/core';
+import { a as PreloadManager } from './dataunit-fetcher.js';
 
 class TaskbarProcessor {
   constructor(defaultButtons) {
@@ -60,6 +61,16 @@ class SnkMultiSelectionListDataSource {
     }
     return String(this._dataUnit.getFormattedValue(fieldName, value));
   }
+  async getStaticOptions(fieldName) {
+    if (fieldName == undefined) {
+      return Promise.resolve(undefined);
+    }
+    const result = await PreloadManager.getDistinct(this._dataUnit, fieldName);
+    if (result == undefined) {
+      return Promise.resolve(undefined);
+    }
+    return Promise.resolve(Array.from(result.entries()).map(([label, value]) => ({ label: String(label), value, check: true })));
+  }
   fetchData(filterTerm, fieldName) {
     return new Promise(resolve => {
       this._application.executeSelectDistinct(this._dataUnit, fieldName, filterTerm).then(result => {