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

package/dist/components/ParamType.js

@@ -0,0 +1,13 @@
+var ParamType;
+(function (ParamType) {
+  ParamType["TEXT"] = "S";
+  ParamType["INTEGER"] = "I";
+  ParamType["DECIMAL"] = "D";
+  ParamType["DATE"] = "DT";
+  ParamType["DATETIME"] = "DH";
+  ParamType["BOOLEAN"] = "B";
+  ParamType["ENTITY"] = "ENTITY";
+  ParamType["OPTIONS"] = "SO";
+})(ParamType || (ParamType = {}));
+
+export { ParamType as P };

package/dist/components/PersonalizedFilterUtils.js

@@ -0,0 +1,260 @@
+import { DataType, NumberUtils, DateUtils, UserInterface } from '@sankhyalabs/core';
+import { F as FilterItemType } from './filter-item-type.enum.js';
+
+var FilterGroupCondition;
+(function (FilterGroupCondition) {
+  FilterGroupCondition["AND"] = "AND";
+  FilterGroupCondition["OR"] = "OR";
+})(FilterGroupCondition || (FilterGroupCondition = {}));
+
+var FilterConfigType;
+(function (FilterConfigType) {
+  FilterConfigType["SYSTEM_CONFIG"] = "S";
+  FilterConfigType["USER_CONFIG"] = "E";
+})(FilterConfigType || (FilterConfigType = {}));
+var FilterUserConfigTypes;
+(function (FilterUserConfigTypes) {
+  FilterUserConfigTypes["DATE"] = "D";
+  FilterUserConfigTypes["HORA"] = "H";
+  FilterUserConfigTypes["TEXT"] = "S";
+  FilterUserConfigTypes["INTEGER"] = "I";
+  FilterUserConfigTypes["DECIMAL"] = "F";
+  FilterUserConfigTypes["NUMBER"] = "NUMBER";
+})(FilterUserConfigTypes || (FilterUserConfigTypes = {}));
+var FilterOperand;
+(function (FilterOperand) {
+  FilterOperand["AND"] = "AND";
+  FilterOperand["OR"] = "OR";
+  FilterOperand["IN"] = "IN";
+  FilterOperand["DIFFERENT"] = "<>";
+  FilterOperand["LIKE"] = "LIKE";
+  FilterOperand["START_WITH"] = "LIKE_START";
+  FilterOperand["FINISHED_WITH"] = "LIKE_END";
+  FilterOperand["NULL"] = "NULL";
+  FilterOperand["NOT_NULL"] = "NOT NULL";
+  FilterOperand["EQUAL"] = "=";
+  FilterOperand["LARGER"] = ">";
+  FilterOperand["LARGER_EQUAL"] = ">=";
+  FilterOperand["SMALLER"] = "<";
+  FilterOperand["SMALLER_EQUAL"] = "<=";
+})(FilterOperand || (FilterOperand = {}));
+var FilterEntities;
+(function (FilterEntities) {
+  FilterEntities["FIELD"] = "Campo";
+  FilterEntities["INSTANCE"] = "Instancia";
+})(FilterEntities || (FilterEntities = {}));
+
+class PersonalizedFilterUtils {
+  /**
+   * Cria uma expressão de filtro a partir de um IExpressionItem.
+   * @param expressionItem - Objeto com os parâmetros necessários para montar a expressão.
+   * @returns Retorna a expressão de filtro.
+   */
+  static buildFilterExpression(expressionItem) {
+    var _a;
+    if (expressionItem == undefined) {
+      return;
+    }
+    let value = (_a = this.buildVariableParameterValue(expressionItem)) !== null && _a !== void 0 ? _a : undefined;
+    let expression = expressionItem.expression || "";
+    let commas = "'";
+    if (expressionItem.paramVariable) {
+      commas = "";
+    }
+    switch (expressionItem.operand) {
+      case "IN":
+        expression += ` ${FilterOperand[expressionItem.operand]} (${value})`;
+        break;
+      case "NULL":
+      case "NOT_NULL":
+        expression += ` IS ${FilterOperand[expressionItem.operand]}`;
+        break;
+      case "LIKE":
+        expression += ` LIKE '%${value}%'`;
+        break;
+      case "START_WITH":
+        expression += ` LIKE '${value}%'`;
+        break;
+      case "FINISHED_WITH":
+        expression += ` LIKE '%${value}'`;
+        break;
+      default:
+        if (expressionItem.operand) {
+          expression += ` ${FilterOperand[expressionItem.operand]}`;
+        }
+        if (['string', 'number'].includes(typeof value)) {
+          value = isNaN(value) ? `${commas}${value}${commas}` : value;
+          expression += ` ${value}`;
+        }
+    }
+    return expression;
+  }
+  /**
+   * Obtém o valor do parâmetro a partir de um IExpressionItem.
+   * @param expressionItem - Objeto com os parâmetros necessários para montar a expressão.
+   * @returns Retorna o valor do parâmetro.
+   */
+  static buildVariableParameterValue(expressionItem) {
+    var _a;
+    if (expressionItem == undefined)
+      return;
+    if (expressionItem.paramVariable) {
+      return this.proccessVarialbeParameter(expressionItem);
+    }
+    if (expressionItem.operand !== FilterOperand.NULL && expressionItem.operand !== "NOT_NULL") {
+      let value = expressionItem.value;
+      const type = expressionItem.type;
+      /*
+       Precisamos validar o expressionItem.userInterface além do expressionItem.type
+       pois para filtros herdados do HTML5 não temos o tipo OBJECT, fazendo com que a expressão
+       fique inválida para campos do tipo pesquisa.
+      */
+      if (UserInterface.SEARCH === expressionItem.userInterface || expressionItem.userInterface === UserInterface.OPTIONSELECTOR || DataType.OBJECT == type) {
+        value = (_a = value === null || value === void 0 ? void 0 : value.value) !== null && _a !== void 0 ? _a : value;
+      }
+      if (DataType.NUMBER == type && value != undefined) {
+        value = NumberUtils.stringToNumber(value);
+        this.checkIsValidNumber(value);
+      }
+      else if (DataType.DATE == type) {
+        value = this.convertDataValue(value);
+      }
+      else if (DataType.BOOLEAN == type) {
+        value = value ? "S" : "N";
+      }
+      return value;
+    }
+    return expressionItem.operand;
+  }
+  static checkIsValidNumber(value) {
+    if (isNaN(value)) {
+      throw new Error('O valor informado não é um número válido.');
+    }
+  }
+  static proccessVarialbeParameter(expressionItem) {
+    if (expressionItem.systemConfig != undefined) {
+      const systemConfig = expressionItem.systemConfig;
+      return `?:{entidade=${systemConfig.entity || ""};campo=${systemConfig.fieldName || ""}}`;
+    }
+    if (expressionItem.userConfig != undefined) {
+      const userConfig = expressionItem.userConfig;
+      return `?:{desc=${userConfig.description || ""};tipo=${userConfig.type || ""}}`;
+    }
+    return `?:{entidade=${expressionItem.entityName || ""};campo=${expressionItem.fieldName || ""}}`;
+  }
+  static convertDataValue(value) {
+    if (typeof value == 'string') {
+      value = new Date(value);
+    }
+    return DateUtils.formatDate(value);
+  }
+  /*
+  * Cria uma expressão de filtro para um grupo de itens.
+  */
+  static buildGroupExpression(expressionGroup) {
+    var _a, _b;
+    if (!((_a = expressionGroup === null || expressionGroup === void 0 ? void 0 : expressionGroup.items) === null || _a === void 0 ? void 0 : _a.length))
+      return "";
+    const itemExpressions = expressionGroup.items.map((item) => this.buildFilterExpression(item)).join(` ${expressionGroup.operand} `);
+    if (((_b = expressionGroup === null || expressionGroup === void 0 ? void 0 : expressionGroup.childrenGroups) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+      const childGroupExpressions = expressionGroup.childrenGroups.map((children) => this.buildGroupExpression(children)).join(` ${expressionGroup.operand} `);
+      return `(${itemExpressions} ${expressionGroup.operand} (${childGroupExpressions}))`;
+    }
+    return `(${itemExpressions})`;
+  }
+  /*
+  * Valida se os campos das expressão estão válidas para serem criada ou editada.
+  */
+  static validateFields(expressionGroup) {
+    const allItems = this.buildPlainExpressionItems(expressionGroup);
+    for (const item of allItems) {
+      const isValidItem = this.validateExpressionItem(item);
+      if (!isValidItem) {
+        return false;
+      }
+    }
+    return true;
+  }
+  static buildPlainExpressionItems(expressionGroup) {
+    const { items = [], childrenGroups = [] } = expressionGroup || {};
+    const getItemsFromChildren = (childrenGroup) => {
+      return childrenGroup.reduce((listAcc, children) => {
+        var _a;
+        if (children.items)
+          listAcc = listAcc.concat(children.items);
+        if ((_a = children.childrenGroups) === null || _a === void 0 ? void 0 : _a.length) {
+          listAcc = listAcc.concat(getItemsFromChildren(children.childrenGroups));
+        }
+        return listAcc;
+      }, []);
+    };
+    return items.concat(getItemsFromChildren(childrenGroups));
+  }
+  static validateExpressionItem(expressionItem) {
+    const requiredFields = {
+      fieldName: (value) => !!value,
+      value: (value, byPassValue) => {
+        if (byPassValue)
+          return true;
+        return value != undefined;
+      },
+      operand: (value) => !!value
+    };
+    const isAllValidFields = Object.entries(requiredFields).every(entries => {
+      const [fieldName, validate] = entries;
+      const byPassValue = expressionItem.paramVariable || expressionItem.userInterface === 'SWITCH' || ["NULL", "NOT_NULL"].includes(expressionItem.operand);
+      return validate(expressionItem[fieldName], byPassValue);
+    });
+    return isAllValidFields;
+  }
+  static getNormalizedValue(params, value) {
+    return params.reduce((arrayValues, currentParam, index) => {
+      if (currentParam.dataType === DataType.BOOLEAN && (arrayValues == undefined || arrayValues[index] == undefined)) {
+        arrayValues = !!arrayValues && !Array.isArray(arrayValues) ? [arrayValues] : arrayValues || [];
+        arrayValues[index] = false;
+      }
+      return arrayValues;
+    }, value);
+  }
+  /*
+  * Valida se os filtros personalizados com campo variável são válido.
+  */
+  static validateVariableValues(config, editorValue) {
+    if (!config)
+      return true;
+    let valuesArray = editorValue || config.value;
+    let isValid = true;
+    if (config.type === FilterItemType.PERSONALIZED) {
+      const activeFilters = (config.groupedItems || []).filter(item => item.visible);
+      const allFilterWithVariableParams = activeFilters.filter(activeFilter => { var _a, _b, _c; return !!((_c = (_b = (_a = activeFilter.props) === null || _a === void 0 ? void 0 : _a.personalizedFilter) === null || _b === void 0 ? void 0 : _b.parameters) === null || _c === void 0 ? void 0 : _c.length); });
+      const allParamsWithValues = allFilterWithVariableParams.flatMap(filter => { var _a; return (_a = filter.props.personalizedFilter) === null || _a === void 0 ? void 0 : _a.parameters; });
+      const valuesFromParams = allFilterWithVariableParams.flatMap(filter => {
+        const isBoolean = filter.props.personalizedFilter.parameters[0].dataType === DataType.BOOLEAN;
+        return isBoolean ? false : filter.value;
+      });
+      valuesArray = this.getNormalizedValue(allParamsWithValues, valuesArray);
+      isValid = allParamsWithValues.length === valuesFromParams.length && valuesFromParams.every(value => value != null);
+    }
+    return isValid;
+  }
+  /*
+  * Constroi uma lista parâmetros para todos os itens de grupos e subgrupos que são
+  * do tipo variavel;
+  */
+  static buildVariableParameters(expressionGroup) {
+    const allItems = this.buildPlainExpressionItems(expressionGroup);
+    const allParams = [];
+    for (const item of allItems) {
+      if (!item.paramVariable) {
+        continue;
+      }
+      allParams.push({
+        entityName: item.entityName,
+        fieldName: item.fieldName
+      });
+    }
+    return allParams;
+  }
+}
+
+export { FilterGroupCondition as F, PersonalizedFilterUtils as P, FilterOperand as a, FilterConfigType as b, FilterEntities as c, FilterUserConfigTypes as d };

package/dist/components/SnkFormConfigManager.js

@@ -0,0 +1,134 @@
+import { C as ConfigStorage } from './ConfigStorage.js';
+import { ObjectUtils } from '@sankhyalabs/core';
+import { F as FormConfigFetcher } from './form-config-fetcher.js';
+
+class SnkFormConfigManager {
+  constructor(configName, onConfigChange) {
+    this._configName = configName;
+    this._onConfigChange = onConfigChange;
+  }
+  async loadConfig() {
+    return new Promise(resolve => {
+      ConfigStorage.get()
+        .then((configStorage) => {
+        configStorage.loadFormConfig(this._configName)
+          .then((config) => {
+          this.setConfig(config);
+          resolve(config);
+        })
+          .catch((error) => {
+          console.warn(error);
+        });
+      });
+    });
+  }
+  saveConfig(config) {
+    const configToSave = ObjectUtils.copy(config);
+    return new Promise(accept => {
+      ConfigStorage.saveFormConfig(config, this._configName)
+        .then((response) => {
+        this.setConfig(Object.assign(Object.assign({}, configToSave), response));
+        accept(Object.assign(Object.assign({}, configToSave), response));
+      });
+    });
+  }
+  saveCardState(cardId, cardConfig, propertyChanged) {
+    return new Promise(resolve => {
+      var _a;
+      const cardsState = ((_a = this._config) === null || _a === void 0 ? void 0 : _a.cardsState) || new Map;
+      const currentConfig = cardsState.get(cardId);
+      cardsState.set(cardId, propertyChanged === "fixed" ?
+        this.updateFixSequence(Object.assign(Object.assign({}, currentConfig), { fixed: cardConfig.fixed }), cardsState)
+        : Object.assign(Object.assign({}, currentConfig), { [propertyChanged]: cardConfig[propertyChanged] }));
+      ConfigStorage.saveCardState(cardsState, this._configName)
+        .then(savedCardConfig => {
+        this._config = Object.assign(Object.assign({}, this._config), { cardsState });
+        resolve(savedCardConfig);
+      });
+    });
+  }
+  updateFixSequence(updatingCardConfig, cardsState) {
+    let maxSequence = -1;
+    Array.from(cardsState.values()).forEach(cardConfig => {
+      if (!cardConfig.fixed) {
+        delete updatingCardConfig.fixSequence;
+      }
+      if (cardConfig.fixSequence != undefined) {
+        maxSequence = Math.max(maxSequence, cardConfig.fixSequence);
+      }
+    });
+    if (updatingCardConfig.fixed) {
+      updatingCardConfig.fixSequence = maxSequence + 1;
+    }
+    else {
+      delete updatingCardConfig.fixSequence;
+    }
+    return updatingCardConfig;
+  }
+  getFieldsList(dataUnit) {
+    var _a;
+    const fields = (_a = this._config) === null || _a === void 0 ? void 0 : _a.fields;
+    if (fields != undefined && fields.length > 0) {
+      return [...fields];
+    }
+    if (dataUnit != undefined) {
+      return dataUnit.metadata.fields
+        .filter(field => field.visible !== false)
+        .map(({ name }) => { return { name }; });
+    }
+    return [];
+  }
+  getInsertionConfig(dataUnit) {
+    const fields = this.getFieldsList(dataUnit).filter(field => {
+      if (dataUnit) {
+        const def = dataUnit.getField(field.name);
+        if (def && def.readOnly) {
+          return false;
+        }
+      }
+      return !field.readOnly;
+    });
+    return Object.assign(Object.assign({}, this._config), { fields });
+  }
+  setConfig(config) {
+    this.isLoaded = true;
+    const { cardsState, summary, defaultVars } = this._config || {};
+    this._config = Object.assign({}, config);
+    if (cardsState) {
+      this._config.cardsState = cardsState;
+    }
+    if (summary) {
+      this._config.summary = summary;
+    }
+    if (defaultVars) {
+      this._config.defaultVars = defaultVars;
+    }
+    if (this._onConfigChange) {
+      this._onConfigChange(Object.assign({}, this._config));
+    }
+  }
+  getConfig(insertionMode, dataUnit) {
+    return insertionMode ? this.getInsertionConfig(dataUnit) : Object.assign({}, this._config);
+  }
+  getFormConfigFetcher() {
+    if (this._formConfigFetcher == undefined) {
+      this._formConfigFetcher = new FormConfigFetcher();
+    }
+    return this._formConfigFetcher;
+  }
+  async fetchUserAvailableConfigs(resourceID) {
+    if (this._configName != undefined) {
+      //FIXME: Precisamos preparar o backend para retornar as configurações disponíveis para details;
+      return Promise.resolve(undefined);
+    }
+    return this.getFormConfigFetcher().fetchUserAvailableConfigs(this._configName, resourceID);
+  }
+  async fetchLegacyConfig(resourceID) {
+    return this.getFormConfigFetcher().fetchLegacyConfig(this._configName, resourceID);
+  }
+  async fetchDefaultConfig(resourceID) {
+    return this.getFormConfigFetcher().fetchDefaultConfig(this._configName, resourceID);
+  }
+}
+
+export { SnkFormConfigManager as S };