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

package/dist/cjs/_commonjsHelpers-537d719a.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+exports.commonjsGlobal = commonjsGlobal;
+exports.createCommonjsModule = createCommonjsModule;

package/dist/cjs/auth-fetcher-58237931.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const core = require('@sankhyalabs/core');
+const resourceFetcher = require('./resource-fetcher-c0332609.js');
+
+class AuthFetcher extends resourceFetcher.ResourceFetcher {
+  getData(resourceID) {
+    const completePath = `cfg://auth/${resourceID}`;
+    return new Promise((resolve, reject) => {
+      this.loadResource(completePath)
+        .then((loadedResource) => {
+        let auth = core.ObjectUtils.stringToObject(loadedResource);
+        if (auth && typeof (auth) === 'object') {
+          resolve(auth);
+        }
+      }).catch((error) => {
+        reject(error);
+      });
+    });
+  }
+}
+exports.AutorizationType = void 0;
+(function (AutorizationType) {
+  AutorizationType["INSERT"] = "I";
+  AutorizationType["UPDATE"] = "A";
+  AutorizationType["REMOVE"] = "E";
+  AutorizationType["SHOW"] = "C";
+  AutorizationType["CONFIG"] = "F";
+  AutorizationType["CONFIG_NUMBER"] = "N";
+  AutorizationType["CLONE"] = "D";
+  AutorizationType["CONFIG_GRID"] = "G";
+})(exports.AutorizationType || (exports.AutorizationType = {}));
+
+exports.AuthFetcher = AuthFetcher;

package/dist/cjs/constants-d187e03e.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const REPORT_LAUNCHER_RESOURCE_ID = "br.com.sankhya.controls.ReportLauncher";
+exports.VIEW_MODE = void 0;
+(function (VIEW_MODE) {
+  VIEW_MODE[VIEW_MODE["GRID"] = 0] = "GRID";
+  VIEW_MODE[VIEW_MODE["FORM"] = 1] = "FORM";
+  VIEW_MODE[VIEW_MODE["ATTACHMENT"] = 2] = "ATTACHMENT";
+})(exports.VIEW_MODE || (exports.VIEW_MODE = {}));
+const ACTION_CONFIG = {
+  add: 'ADD',
+  remove: 'REMOVE',
+  configuration: 'CONFIGURATION'
+};
+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}" }
+    ]
+  }
+};
+const DEFAULT_TYPE = {
+  fixed: "F",
+  variable: "V"
+};
+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"
+};
+const KEY_EVENTS = {
+  enter: "Enter",
+  arrowLeft: "ArrowLeft",
+  arrowRight: "ArrowRight",
+  tab: "Tab",
+  escape: "Escape"
+};
+const TYPE_ACTIONS = {
+  rename: "RENAME",
+  hide: "HIDE",
+  show: "SHOW",
+  delete: "DELETE"
+};
+const TAB_NAMES = {
+  main: "__main"
+};
+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"
+};
+const ORDER_VALUES = {
+  none: {
+    value: "NA",
+    label: "N/A",
+  },
+  asc: {
+    value: "ASC",
+    label: "A-Z"
+  },
+  desc: {
+    value: "DESC",
+    label: "Z-A"
+  }
+};
+exports.SIMPLE_CRUD_MODE = void 0;
+(function (SIMPLE_CRUD_MODE) {
+  SIMPLE_CRUD_MODE[SIMPLE_CRUD_MODE["SERVER"] = 0] = "SERVER";
+  SIMPLE_CRUD_MODE[SIMPLE_CRUD_MODE["IN_MEMORY"] = 1] = "IN_MEMORY";
+})(exports.SIMPLE_CRUD_MODE || (exports.SIMPLE_CRUD_MODE = {}));
+
+exports.ACTION_CONFIG = ACTION_CONFIG;
+exports.CONFIG_EVENTS = CONFIG_EVENTS;
+exports.DEFAULT_TYPE = DEFAULT_TYPE;
+exports.KEY_EVENTS = KEY_EVENTS;
+exports.ORDER_VALUES = ORDER_VALUES;
+exports.REPORT_LAUNCHER_RESOURCE_ID = REPORT_LAUNCHER_RESOURCE_ID;
+exports.TAB_NAMES = TAB_NAMES;
+exports.TAGS_BY_TYPE = TAGS_BY_TYPE;
+exports.TYPE_ACTIONS = TYPE_ACTIONS;
+exports.VARS_BY_TYPE = VARS_BY_TYPE;

package/dist/cjs/dataunit-fetcher-029eafbd.js

@@ -0,0 +1,356 @@
+'use strict';
+
+const core = require('@sankhyalabs/core');
+const DataFetcher = require('./DataFetcher-004811c6.js');
+const constants = require('@sankhyalabs/ezui/dist/collection/utils/constants');
+const UnitMetadata = require('@sankhyalabs/core/dist/dataunit/metadata/UnitMetadata');
+
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+class DataUnitFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this._loadDataTimeout = {};
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this.templateByQuery.set("fetchDataUnit", DataFetcher.dist.gql `query($name: String!) {
+              $queryAlias$: fetchDataUnit(name: $name){
+                name
+                fields{
+                  name
+                  defaultValue
+                  label
+                  visible
+                  readOnly
+                  required
+                  dataType
+                  userInterface
+                  calculated
+                  group
+                  order
+                  properties{
+                    name
+                    value
+                  }
+                  dependencies{
+                    masterFields
+                    type
+                    expression
+                  }
+                }
+                children{
+                  name
+                  label
+                  links{
+                    source
+                    target
+                  }
+                }
+              }
+            }`);
+    this.templateByQuery.set("fetchData", DataFetcher.dist.gql `query($dataunit: String! $limit: Int $offset:Int $filters: [InputFilter!] $sort: [InputSort!] $parentRecordId: String) {
+            $queryAlias$: fetchDataUnit(name: $dataunit){
+              data(limit: $limit offset: $offset filters: $filters sort: $sort parentRecordId: $parentRecordId){
+                limit
+                offset
+                total
+                hasMore
+                records{
+                  id
+                  label
+                  fields {
+                    name
+                    value
+                  }
+                }
+              }
+            }
+          }`);
+    this.templateByQuery.set("saveData", DataFetcher.dist.gql `mutation($changes: [InputBatchChange!]!) {
+            $queryAlias$: batchOperationDataUnit(changes: $changes){
+              oldId
+              id
+              label
+              ownerDataUnitName
+              fields {
+                name
+                value
+              }
+            }
+          }`);
+    this.templateByQuery.set("fetchDataRecord", DataFetcher.dist.gql `query($dataunit: String! $recordID: [String!]) {
+            $queryAlias$: fetchDataUnit(name: $dataunit){
+              record(id: $recordID){
+                id
+                label
+                fields {
+                  name
+                  value
+                }
+              }
+            }
+          }`);
+    this.templateByQuery.set("fetchDistinctColumn", DataFetcher.dist.gql `query($dataUnit: String!, $fieldName: String!, $argument: String, $filters: [InputFilter], $parentRecordId: String) {
+          $queryAlias$: selectDistinct(dataUnit: $dataUnit, fieldName: $fieldName, argument: $argument, filters: $filters, parentRecordId: $parentRecordId)
+      }`);
+  }
+  getDataUnit(entityName, resourceID, parentDataUnit, configName) {
+    const duName = `dd://${entityName}/${resourceID}${configName ? "/" + configName : ""}`;
+    const dataUnit = parentDataUnit != undefined ? parentDataUnit.getChildDataunit(duName) : new core.DataUnit(duName);
+    dataUnit.metadataLoader = (dataUnit) => this.loadMetadata(dataUnit);
+    dataUnit.dataLoader = (dataUnit, request) => this.loadData(dataUnit, request);
+    dataUnit.saveLoader = (_dataUnit, changes) => this.saveData(dataUnit, changes);
+    dataUnit.removeLoader = (dataUnit, recordIds) => this.removeRecords(dataUnit, recordIds);
+    dataUnit.recordLoader = (dataUnit, recordIds) => this.loadRecord(dataUnit, recordIds);
+    return dataUnit;
+  }
+  loadMetadata(dataUnit) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name: dataUnit.name },
+        query: this.templateByQuery.get("fetchDataUnit"),
+      })
+        .then((resp) => {
+        var _a;
+        const metadata = {
+          name: resp.name,
+          label: resp.name,
+          children: [...resp.children],
+          fields: []
+        };
+        (_a = resp.fields) === null || _a === void 0 ? void 0 : _a.forEach((source) => {
+          let properties = undefined;
+          if (Array.isArray(source.properties)) {
+            properties = {};
+            if (source.calculated) {
+              properties.gridHeaderTooltip = "Campos calculados não podem ser ordenados";
+            }
+            source.properties.forEach((prop) => (properties[prop.name] = prop.value));
+          }
+          metadata.fields.push(Object.assign(Object.assign({}, source), { properties }));
+        });
+        metadata.fields.sort((a, b) => a.order - b.order);
+        resolve(metadata);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  async loadData(dataUnit, request) {
+    try {
+      const duName = dataUnit.name;
+      if (this._loadDataTimeout[duName]) {
+        clearTimeout(this._loadDataTimeout[duName]);
+        delete this._loadDataTimeout[duName];
+      }
+      const result = await this.doLoadData(dataUnit, request);
+      delete this._loadDataTimeout[duName];
+      await new Promise(resolve => {
+        this._loadDataTimeout[duName] = setTimeout(resolve, 200);
+      });
+      return Promise.resolve(result);
+    }
+    catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  loadSelectDistinct(dataUnit, fieldName, argument) {
+    const { parentRecordId, filters } = dataUnit.getLastLoadRequest() || {};
+    const filteredFilters = filters.filter(f => f.name !== `${constants.DISTINCT_FILTER_NAME_PREFIX}${fieldName}`);
+    const values = {
+      dataUnit: dataUnit.name,
+      argument,
+      fieldName,
+      parentRecordId,
+      filters: filteredFilters
+    };
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values,
+        query: this.templateByQuery.get("fetchDistinctColumn"),
+      })
+        .then((result) => {
+        resolve(result);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  doLoadData(dataUnit, request) {
+    return new Promise((resolve, reject) => {
+      var _a;
+      const { sort, filters, limit, offset, quickFilter } = request;
+      const variables = { dataunit: dataUnit.name, sort, filters };
+      variables.limit = limit;
+      variables.offset = offset;
+      variables.parentRecordId = request.parentRecordId;
+      if (!core.StringUtils.isEmpty(quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.term)) {
+        if (variables.filter === undefined) {
+          variables.filter = [];
+        }
+        const quickFilterCriteria = {
+          name: "__QUICK_FILTER__",
+          expression: "__QUICK_FILTER__",
+          params: [{ name: "term", dataType: core.DataType.TEXT, value: quickFilter.term }]
+        };
+        if (((_a = quickFilter === null || quickFilter === void 0 ? void 0 : quickFilter.fields) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+          quickFilterCriteria.params.push({ name: "fields", dataType: core.DataType.OBJECT, value: quickFilter.fields });
+        }
+        variables.filter.push(quickFilterCriteria);
+      }
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: variables,
+        query: this.templateByQuery.get("fetchData"),
+      })
+        .then((resp) => {
+        const { limit, offset, total, hasMore, records } = resp.data;
+        let paginationInfo;
+        if (limit) {
+          const firstRecord = total == 0 ? 0 : offset + 1;
+          const lastRecord = offset + Math.min(records.length, limit);
+          const currentPage = offset / limit;
+          paginationInfo = {
+            firstRecord,
+            lastRecord,
+            total,
+            currentPage,
+            hasMore
+          };
+        }
+        const processedRecords = [];
+        records.forEach((responseRecord) => {
+          const duRecord = { __record__id__: responseRecord.id, __record__label__: responseRecord.label };
+          responseRecord.fields.forEach(({ name, value }) => {
+            duRecord[name] = dataUnit.valueFromString(name, value);
+          });
+          processedRecords.push(duRecord);
+        });
+        resolve({
+          paginationInfo,
+          records: processedRecords
+        });
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  saveData(dataUnit, duChanges) {
+    const changes = duChanges.map((change) => {
+      const { dataUnit: changeDU, record, updatingFields, operation } = change;
+      const dataUnitInstance = core.DataUnitStorage.get(changeDU);
+      let parsedUpdatingFields;
+      if (updatingFields) {
+        parsedUpdatingFields = Object.entries(updatingFields).map(([fieldName, value]) => {
+          const descriptor = dataUnitInstance.getField(fieldName);
+          const dataType = descriptor ? descriptor.dataType : core.DataType.TEXT;
+          return { fieldName, dataType, value: dataUnitInstance.valueToString(fieldName, value) };
+        });
+      }
+      const reqChange = { dataUnit: changeDU, fields: parsedUpdatingFields, operation, recordId: record.__record__id__ };
+      if (change.sourceId) {
+        reqChange.sourceId = change.sourceId;
+      }
+      if (record.__parent__record__id__) {
+        reqChange.parentRecordId = record.__parent__record__id__;
+      }
+      return reqChange;
+    });
+    return new Promise((resolve, reject) => {
+      const changesFormatted = changes.map((_a) => {
+        var rest = __rest(_a, []);
+        return rest;
+      });
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { changes: changesFormatted },
+        query: this.templateByQuery.get("saveData"),
+      })
+        .then((resp) => {
+        const dataUnitRecords = [];
+        resp === null || resp === void 0 ? void 0 : resp.forEach((responseRecord) => {
+          const duRecord = {
+            __record__id__: responseRecord.id,
+            __record__label__: responseRecord.label,
+            __owner__dataunit__name__: responseRecord.ownerDataUnitName,
+          };
+          const dataUnitInstance = core.DataUnitStorage.get(duRecord.__owner__dataunit__name__) || dataUnit;
+          if (responseRecord.oldId) {
+            duRecord.__old__id__ = responseRecord.oldId;
+          }
+          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;
+          });
+          dataUnitRecords.push(duRecord);
+        });
+        resolve(dataUnitRecords);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  getTransientInfo(dataUnit, recordID) {
+    const { records } = dataUnit.getSelectionInfo();
+    return Object.entries(records.filter(record => record.__record__id__ == recordID)[0]).filter(([key]) => key.startsWith(UnitMetadata.DataUnitTransient.DATA_UNIT_TRANSIENT_PREFIX_NAME)).map(([name, value]) => ({ fieldName: name, value, dataType: core.DataType.TEXT }));
+  }
+  removeRecords(dataUnit, recordIds) {
+    const changes = recordIds.map((recordId) => {
+      return { dataUnit: dataUnit.name, operation: core.ChangeOperation.DELETE, recordId, fields: this.getTransientInfo(dataUnit, recordId) };
+    });
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { changes: changes },
+        query: this.templateByQuery.get("saveData"),
+      })
+        .then((_resp) => {
+        resolve(recordIds);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadRecord(dataUnit, recordIds) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { recordID: recordIds, dataunit: dataUnit.name },
+        query: this.templateByQuery.get("fetchDataRecord"),
+      })
+        .then((response) => {
+        const dataUnitRecords = [];
+        response.record.forEach(responseRecord => {
+          const duRecord = { __record__id__: responseRecord.id, __record__label__: responseRecord.label };
+          responseRecord.fields.forEach(({ name, value }) => {
+            duRecord[name] = dataUnit.valueFromString(name, value);
+          });
+          dataUnitRecords.push(duRecord);
+        });
+        resolve(dataUnitRecords);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+}
+
+exports.DataUnitFetcher = DataUnitFetcher;