@sankhyalabs/sankhyablocks 5.19.0 → 6.0.0

package/dist/cjs/ConfigStorage-0a738cdc.js

@@ -0,0 +1,304 @@
+'use strict';
+
+const core = require('@sankhyalabs/core');
+const formConfigFetcher = require('./form-config-fetcher-92bc8fe7.js');
+const resourceFetcher = require('./resource-fetcher-2979b54b.js');
+const filterBarConfigFetcher = require('./filter-bar-config-fetcher-75219599.js');
+const DataFetcher = require('./DataFetcher-a9d0228f.js');
+
+class GridConfigFetcher extends resourceFetcher.ResourceFetcher {
+  constructor() {
+    super(...arguments);
+    this.GRID_CONFIG_VERSION = "V3:";
+  }
+  getConfig(gridName, resourceID) {
+    const completePath = this.getPath(resourceID, gridName);
+    return new Promise((resolve, reject) => {
+      this.loadResource(completePath)
+        .then(loadedResource => {
+        let config = undefined;
+        if (loadedResource) {
+          config = JSON.parse(loadedResource);
+        }
+        resolve(config);
+      }).catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  saveConfig(config, gridName, resourceID) {
+    const completePath = this.getPath(resourceID, gridName);
+    return new Promise((resolve, reject) => {
+      this.saveResource(config, completePath)
+        .then((resp) => {
+        resolve(JSON.parse(resp.resource));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  getPath(resourceID, name) {
+    if (name) {
+      return `cfg://grid/${this.GRID_CONFIG_VERSION}${resourceID}/${name}`;
+    }
+    return `cfg://grid/${this.GRID_CONFIG_VERSION}${resourceID}`;
+  }
+}
+
+class PersonalizedFilterFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this.buildTemplates();
+  }
+  resolveURI(resourceID, configName) {
+    let uri = "filter-assistent-config://" + resourceID;
+    if (configName) {
+      uri += "." + configName;
+    }
+    return uri;
+  }
+  buildTemplates() {
+    this.templateByQuery.set("fetchFilterFields", DataFetcher.dist.gql `
+    query($name: String!) {
+      $queryAlias$: fetchFilterFields(name: $name){
+        currentLink {
+          description
+          uri
+        }
+        links {
+          description
+          uri
+          fieldCount
+        }
+        fields {
+          name
+          description
+          uri
+          onlyDate
+          dataType
+          userInterface
+          entityName
+          properties {
+            name
+            value
+          }
+        }
+      }
+    }
+    `);
+    this.templateByQuery.set("fetchFilterAssistent", DataFetcher.dist.gql `
+    query($name: String!) {
+      $queryAlias$: fetchFilterAssistent(name: $name) {
+        id
+        name
+        active
+        expression
+        warningMessage
+        parameters {
+          entityName
+          fieldName
+          dataType
+          description
+          userInterface
+          label
+          searchContext {
+            entity
+            entityDescription
+            searchOptions {
+              rootEntity
+              descriptionFieldName
+              codeFieldName
+              showInactives
+            }
+          }
+        }
+        assistent
+      }
+    }`);
+    this.templateByQuery.set("savePersonalizedFilter", DataFetcher.dist.gql ` 
+    mutation($name: String!, $filterAssistent: InputFilterAssistent!)  {
+      $queryAlias$: savePersonalizedFilter(name: $name, filterAssistent: $filterAssistent) {
+        id
+        name
+      }
+    }`);
+    this.templateByQuery.set("deletePersonalizedFilter", DataFetcher.dist.gql `
+    mutation($name: String!, $filterId: String!) {
+      $queryAlias$: deletePersonalizedFilter(name: $name, filterId: $filterId) {
+        id
+        name
+      }
+    }`);
+  }
+  async loadPersonalizedFilter(resourceID, filterID, configName) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name: this.resolveURI(resourceID, configName) + "/" + filterID },
+        query: this.templateByQuery.get("fetchFilterAssistent"),
+      })
+        .then((resp) => {
+        resp.assistent = JSON.parse(resp.assistent);
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  async savePersonalizedFilter(personalizedFilter, resourceID, configName) {
+    let personalizedFilterParsed = JSON.parse(JSON.stringify(personalizedFilter));
+    personalizedFilterParsed.assistent = JSON.stringify(personalizedFilterParsed.assistent);
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name: this.resolveURI(resourceID, configName), filterAssistent: personalizedFilterParsed },
+        query: this.templateByQuery.get("savePersonalizedFilter"),
+      })
+        .then((resp) => {
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  async removePersonalizedFilter(personalizedFilter, resourceID, configName) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name: this.resolveURI(resourceID, configName), filterId: personalizedFilter.id },
+        query: this.templateByQuery.get("deletePersonalizedFilter"),
+      })
+        .then((resp) => {
+        resolve(resp);
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+  loadFields(uri) {
+    return new Promise((resolve, reject) => {
+      DataFetcher.DataFetcher.get()
+        .callGraphQL({
+        values: { name: uri },
+        query: this.templateByQuery.get("fetchFilterFields"),
+      })
+        .then((resp) => {
+        var _a;
+        let fields = resp.fields;
+        for (const field of fields) {
+          if (Array.isArray(field.properties) && field.properties.length > 0) {
+            const propertiesConvertedObject = field.properties.reduce((accumulator, prop) => {
+              accumulator[prop.name] = prop.value;
+              return accumulator;
+            }, {});
+            field.properties = propertiesConvertedObject;
+          }
+          if ((_a = field === null || field === void 0 ? void 0 : field.properties) === null || _a === void 0 ? void 0 : _a.options) {
+            field.properties.options = JSON.parse(field.properties.options);
+          }
+        }
+        resolve(Object.assign(Object.assign({}, resp), { fields: fields }));
+      })
+        .catch((error) => {
+        reject(error);
+      });
+    });
+  }
+}
+
+const CONFIG_SOURCE = {
+  form: "form",
+  grid: "grid",
+  filterBar: "filterBar"
+};
+class ConfigStorage {
+  static async get() {
+    if (!ConfigStorage.instance) {
+      const application = core.ApplicationContext.getContextValue("__SNK__APPLICATION__");
+      if (application != undefined) {
+        const configName = application.configName;
+        const resourceID = await application.getResourceID();
+        ConfigStorage.instance = new ConfigStorage();
+        ConfigStorage.resourceID = resourceID;
+        ConfigStorage.instance.loadFilterBarConfig(configName);
+        ConfigStorage.instance.loadFormConfig(configName);
+        ConfigStorage.instance.loadGridConfig(configName);
+      }
+    }
+    return this.instance;
+  }
+  async loadFilterBarConfig(name) {
+    const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.filterBar);
+    if (!ConfigStorage.configById.has(cacheID)) {
+      ConfigStorage.configById.set(cacheID, ConfigStorage.filterBarConfigFetcher.getConfig(ConfigStorage.resourceID, name));
+    }
+    return ConfigStorage.configById.get(cacheID);
+  }
+  async loadFormConfig(name) {
+    const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.form);
+    if (!ConfigStorage.configById.has(cacheID)) {
+      ConfigStorage.configById.set(cacheID, ConfigStorage.formConfigFetcher.loadFormConfig(name, ConfigStorage.resourceID));
+    }
+    return ConfigStorage.configById.get(cacheID);
+  }
+  async loadGridConfig(name) {
+    const cacheID = ConfigStorage.buildCacheID(name, CONFIG_SOURCE.grid);
+    if (!ConfigStorage.configById.has(cacheID)) {
+      ConfigStorage.configById.set(cacheID, ConfigStorage.gridConfigFetcher.getConfig(name, ConfigStorage.resourceID));
+    }
+    return ConfigStorage.configById.get(cacheID);
+  }
+  static async saveFilterBarConfig(config, name) {
+    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.filterBar);
+    this.configById.delete(cacheID);
+    return this.filterBarConfigFetcher.saveConfig(config, this.resourceID, name);
+  }
+  static async saveFormConfig(config, name) {
+    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.form);
+    this.configById.delete(cacheID);
+    return this.formConfigFetcher.saveConfig(config, name, this.resourceID);
+  }
+  static async saveCardState(config, name) {
+    return this.formConfigFetcher.saveCardState(config, name, this.resourceID);
+  }
+  static async saveGridConfig(config, name) {
+    if (config == undefined) {
+      return;
+    }
+    const cacheID = this.buildCacheID(name, CONFIG_SOURCE.grid);
+    this.configById.delete(cacheID);
+    return this.gridConfigFetcher.saveConfig(config, name, this.resourceID);
+  }
+  static async loadPersonalizedFilter(filterId, configName) {
+    return this.personalizedFilterFetcher.loadPersonalizedFilter(this.resourceID, filterId, configName);
+  }
+  static async savePersonalizedFilter(personalizedFilter, configName) {
+    //Ao criar ou alterar um filtro personalizado, 
+    //precisamos remover o cache do status da filterbar.
+    const cacheID = this.buildCacheID(configName, CONFIG_SOURCE.filterBar);
+    this.configById.delete(cacheID);
+    return this.personalizedFilterFetcher.savePersonalizedFilter(personalizedFilter, this.resourceID, configName);
+  }
+  static async removePersonalizedFilter(personalizedFilter, configName) {
+    return this.personalizedFilterFetcher.removePersonalizedFilter(personalizedFilter, this.resourceID, configName);
+  }
+  static buildCacheID(name, source) {
+    if (name == undefined) {
+      return `req_${source}_${this.resourceID}`;
+    }
+    return `req_${source}_${name}_${this.resourceID}`;
+  }
+}
+ConfigStorage.configById = new Map();
+ConfigStorage.filterBarConfigFetcher = new filterBarConfigFetcher.FilterBarConfigFetcher();
+ConfigStorage.formConfigFetcher = new formConfigFetcher.FormConfigFetcher();
+ConfigStorage.gridConfigFetcher = new GridConfigFetcher();
+ConfigStorage.personalizedFilterFetcher = new PersonalizedFilterFetcher();
+
+exports.ConfigStorage = ConfigStorage;
+exports.GridConfigFetcher = GridConfigFetcher;
+exports.PersonalizedFilterFetcher = PersonalizedFilterFetcher;

package/dist/cjs/IExpressionItem-1090c3fd.js

@@ -0,0 +1,7 @@
+'use strict';
+
+exports.FilterGroupCondition = void 0;
+(function (FilterGroupCondition) {
+  FilterGroupCondition["AND"] = "AND";
+  FilterGroupCondition["OR"] = "OR";
+})(exports.FilterGroupCondition || (exports.FilterGroupCondition = {}));

package/dist/cjs/PersonalizedFilterUtils-7d959e91.js

@@ -0,0 +1,229 @@
+'use strict';
+
+const core = require('@sankhyalabs/core');
+const index = require('./index-614af008.js');
+const filterItemType_enum = require('./filter-item-type.enum-aa823a00.js');
+
+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, ignoreInvalidExpressions = false) {
+    if (expressionItem == undefined) {
+      return;
+    }
+    if (!this.validateExpressionItem(expressionItem) && ignoreInvalidExpressions) {
+      return "";
+    }
+    let value = this.buildVariableParameterValue(expressionItem);
+    let expression = expressionItem.expression || "";
+    let commas = "'";
+    if (expressionItem.paramVariable) {
+      commas = "";
+    }
+    switch (expressionItem.operand) {
+      case "IN":
+        expression += ` ${index.FilterOperand[expressionItem.operand]} (${value})`;
+        break;
+      case "NULL":
+      case "NOT_NULL":
+        expression += ` IS ${index.FilterOperand[expressionItem.operand]}`;
+        break;
+      case "LIKE":
+        expression += ` LIKE ${commas}%${value}%${commas}`;
+        break;
+      case "START_WITH":
+        expression += ` LIKE ${commas}${value}%${commas}`;
+        break;
+      case "FINISHED_WITH":
+        expression += ` LIKE ${commas}%${value}${commas}`;
+        break;
+      default:
+        value = isNaN(value) ? `${commas}${value}${commas}` : value;
+        expression += ` ${index.FilterOperand[expressionItem.operand]} ${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 !== index.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 (core.UserInterface.SEARCH === expressionItem.userInterface || core.DataType.OBJECT == type) {
+        value = (_a = value === null || value === void 0 ? void 0 : value.value) !== null && _a !== void 0 ? _a : value;
+      }
+      if (core.DataType.NUMBER == type && value != undefined) {
+        value = core.NumberUtils.stringToNumber(value);
+        this.checkIsValidNumber(value);
+      }
+      else if (core.DataType.DATE == type) {
+        value = this.convertDataValue(value);
+      }
+      else if (core.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 core.DateUtils.formatDate(value);
+  }
+  /*
+  * Cria uma expressão de filtro para um grupo de itens.
+  */
+  static buildGroupExpression(expressionGroup, ignoreInvalidExpressions = false) {
+    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, ignoreInvalidExpressions)).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;
+      },
+      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 === core.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_enum.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 === core.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) {
+    var _a, _b, _c, _d;
+    const allItems = this.buildPlainExpressionItems(expressionGroup);
+    const allParams = [];
+    for (const item of allItems) {
+      if (!item.paramVariable) {
+        continue;
+      }
+      allParams.push({
+        entityName: item.entityName,
+        fieldName: item.fieldName,
+        dataType: item.type,
+        description: item.description,
+        userInterface: item.userInterface,
+        label: item.fieldLabel,
+        searchContext: {
+          entity: (_b = (_a = item.props) === null || _a === void 0 ? void 0 : _a.find(prop => prop.name == "ENTITYNAME")) === null || _b === void 0 ? void 0 : _b.value,
+          entityDescription: (_d = (_c = item.props) === null || _c === void 0 ? void 0 : _c.find(prop => prop.name == "DESCRIPTIONENTITY")) === null || _d === void 0 ? void 0 : _d.value,
+          searchOptions: {
+            showInactives: false
+          }
+        }
+      });
+    }
+    return allParams;
+  }
+}
+
+exports.PersonalizedFilterUtils = PersonalizedFilterUtils;

package/dist/cjs/{SnkFormConfigManager-69df3f74.js → SnkFormConfigManager-a583f503.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const ConfigStorage = require('./ConfigStorage-f68c3607.js');
+const ConfigStorage = require('./ConfigStorage-0a738cdc.js');
 const core = require('@sankhyalabs/core');
 const formConfigFetcher = require('./form-config-fetcher-92bc8fe7.js');
 

package/dist/cjs/{SnkMessageBuilder-3b5b5614.js → SnkMessageBuilder-8a2d3f26.js}

@@ -77,6 +77,8 @@ const snkFilterBarMessages = {
   "modalPersonalizedFilterTitle": "Filtro personalizado",
   "modalPersonalizedFilterSubTitle": "Gerencie seus filtros",
   "modalInfoTextCreateEditPersonalized": "Use o layout antigo para criar ou editar filtros, em breve traremos uma nova experiência",
+  "modalInfoTextCreateFilter": "Criar filtro personalizado",
+  "modalInfoTextNoFilterRegister": "Você não possui filtros cadastrados.",
   "modalOkButtonLabel": "Aplicar",
   "modalCancelButtonLabel": "Limpar",
   "binarySelectTooltip": "Exibindo registros",
@@ -87,13 +89,24 @@ const snkFilterBarMessages = {
   "labelStartDatePeriod": "Inicial",
   "labelEndDatePeriod": "Final",
   "filters": "Filtros",
+  "personalizedCount": "{{activeCount}} selecionado(s)",
   "filterModal": {
     "title": "Filtros",
     "okButtonLabel": "Aplicar",
     "cancelButtonLabel": "Limpar tudo",
     "customFilters": "Filtros personalizados",
-    "quickFilters": "Filtros rápidos"
-  }
+    "quickFilters": "Filtros rápidos",
+    "validations": {
+      "notFullFilled": {
+        "title": "Filtro parcialmente preenchido",
+        "message": "Favor completar todas as informações do filtro."
+      },
+      "notSaved": {
+        "title": "Atenção",
+        "message": "As alterações realizadas não serão aplicadas.<br/><br/><b>Deseja mesmo continuar?</b>"
+      }
+    }
+  },
 };
 
 const snkTaskbarMessages = {
@@ -314,6 +327,8 @@ const snkFilterFieldSearchMessages = {
   searchLabel: "Buscar campo",
   fieldLabel: "Campos de {{link}}",
   linkLabel: "Categorias de {{link}}",
+  groupEmpty: "Não há categorias para seleção",
+  searchEmpty: "Nenhum resultado encontrado"
 };
 
 const snkSimpleBarMessages = {
@@ -349,14 +364,60 @@ const snkAttachMessages = {
 
 const snkPersonalizedFilterMessages = {
   info: {
+    titleEdit: "Editar filtro personalizado",
+    titleAdd: "Criar filtro personalizado",
+    titleCollapsible: "Expressão a ser aplicada (gerada pelo assistente)",
     labelSearchField: "Buscar campo",
     labelOperator: "Operador",
     labelValueVarible: "Valor variável",
-    titleTooltip: "Ao ativar um valor variável, é possível inserir um valor diferente sempre que o filtro for aplicado"
+    titleTooltip: "Ao ativar um valor variável, é possível inserir um valor diferente sempre que o filtro for aplicado",
+    labelAddNewExpression: "Adicionar nova linha de expressão",
+    labelDeleteExpression: "Remover expressão",
+    labelDeleteItem: "Remover item",
+    labelDisabledAddGroupButton: "Filtros Personalizados possuem um limite de {{LIMIT_GROUP_LEVEL}} Grupos de Condições e Valores",
+    labelDisabledAddExpressionButton: "Preencha campos obrigatórios ou indique valores variáveis nas expressões do grupo antes de adicionar mais itens",
+    labelCancel: "Cancelar",
+    labelSave: "Salvar",
+    labelNameFilter: "Nome do filtro",
+    labelExpression: "Expressão SQL",
+    badgeVariable: "variável",
+    noDataFound: "Nenhum filtro encontrado"
   },
-  confirm: {
+  confirmExpression: {
     title: "Aviso",
     description: `As informações da condição serão descartadas.</br></br><b>Gostaria de continuar?</b>`
+  },
+  confirmGroup: {
+    title: "Aviso",
+    description: `As informações do Grupo e suas Condições serão descartadas.</br></br><b>Gostaria de continuar?</b>`
+  },
+  confirmCancel: {
+    title: "Aviso",
+    description: `As alterações realizadas serão descartadas.</br></br><b>Gostaria de continuar?</b>`
+  },
+  operador: {
+    firstLevel: "A seleção será habilitada a partir da adição da segunda linha de regras.",
+    and: "Será verdadeiro se todas as condições forem obedecidas.",
+    or: "Será verdadeiro se qualquer uma das condições for obedecida."
+  },
+  error: {
+    title: "Atenção",
+    description: "Há pelo menos um campo obrigatório não preenchido."
+  },
+  confirmSave: {
+    title: "O filtro <b>{{name}}</b> foi salvo com sucesso"
+  },
+  deleteConfirm: {
+    title: "Aviso",
+    message: "Deseja realmente excluir o filtro '{{filterName}}'?"
+  },
+  listActions: {
+    edit: "Editar",
+    delete: "Excluir"
+  },
+  footerActions: {
+    clear: "Limpar",
+    create: "Criar filtro"
   }
 };