@truedat/dq 4.56.4 → 4.56.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [4.56.6] 2022-11-28
+
+### Added
+
+- [TD-5247] FieldSummary and reference dataset table name
+
+## [4.56.5] 2022-11-28
+
+### Changed
+
+- [TD-4711] Improve error reporting for implementation upload
+
 ## [4.56.4] 2022-11-26
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.56.4",
+  "version": "4.56.6",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -34,7 +34,7 @@
     "@testing-library/jest-dom": "^5.16.4",
     "@testing-library/react": "^12.0.0",
     "@testing-library/user-event": "^13.2.1",
-    "@truedat/test": "4.56.4",
+    "@truedat/test": "4.56.6",
     "babel-jest": "^28.1.0",
     "babel-plugin-dynamic-import-node": "^2.3.3",
     "babel-plugin-lodash": "^3.3.4",
@@ -93,8 +93,8 @@
   },
   "dependencies": {
     "@apollo/client": "^3.7.0",
-    "@truedat/core": "4.56.4",
-    "@truedat/df": "4.56.4",
+    "@truedat/core": "4.56.6",
+    "@truedat/df": "4.56.6",
     "graphql": "^15.5.3",
     "path-to-regexp": "^1.7.0",
     "prop-types": "^15.8.1",
@@ -114,5 +114,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 0.88.2 < 2.1"
   },
-  "gitHead": "f327860aa80db650f562d53dc22218307f43e0ac"
+  "gitHead": "4291488ebae029cd8910dbd45ada4ef2e66bfecc"
 }

package/src/components/ConditionCell.js

@@ -0,0 +1,268 @@
+import _ from "lodash/fp";
+import React, { Fragment } from "react";
+import PropTypes from "prop-types";
+import { Icon, Table } from "semantic-ui-react";
+import { useIntl } from "react-intl";
+import { linkTo } from "@truedat/core/routes";
+import { Link } from "react-router-dom";
+import { FormattedMessage } from "react-intl";
+
+const QualifyAndLinkStructure = ({ value, aliasArray }) =>
+  value?.id || value?.data_structure_id ? (
+    <Link to={linkTo.STRUCTURE({ id: value?.id || value?.data_structure_id })}>
+      <div className="highlighted">
+        {qualifySqlIdentifier({ aliasArray, value })}
+      </div>{" "}
+    </Link>
+  ) : (
+    <div>{qualifySqlIdentifier({ aliasArray, value })}</div>
+  );
+
+QualifyAndLinkStructure.propTypes = {
+  value: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),
+  aliasArray: PropTypes.array,
+};
+
+const FormattedLink = ({ value, aliasArray, operator = {} }) => {
+  switch (operator?.value_type) {
+    case "field":
+      return <QualifyAndLinkStructure value={value} aliasArray={aliasArray} />;
+    case "field_list":
+      return (
+        <>
+          {_.map.convert({ cap: false })((v, i) => (
+            <QualifyAndLinkStructure
+              key={i}
+              value={v}
+              aliasArray={aliasArray}
+            />
+          ))(value)}
+        </>
+      );
+    default:
+      return (
+        <span className="highlighted">
+          <FormattedMessage
+            id={`ruleImplementation.filtersField.${value.raw}`}
+            defaultMessage={`"${
+              _.isArray(value.raw) ? _.join(", ")(value.raw) : value.raw
+            }"`}
+          ></FormattedMessage>
+        </span>
+      );
+  }
+};
+
+FormattedLink.propTypes = {
+  value: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),
+  operator: PropTypes.object,
+  aliasArray: PropTypes.array,
+};
+
+const nilOrEmpty = (v) => _.isNil(v) || v === "";
+
+const filterNilOrEmpties = (values, keys) => {
+  if ("kv" in values) {
+    return _.every((k) => !nilOrEmpty(values.kv[k]))(keys) ? values : null;
+  }
+
+  return _.flow(
+    _.map((v) => filterNilOrEmpties(v, keys)),
+    _.filter((v) => !!v)
+  )(values);
+};
+
+const pick = (value, keys, optionalKeys) => ({
+  kv: _.pick(keys)(value),
+  optv: _.pick(optionalKeys)(value),
+});
+
+const convert = (v, index, value_modifier) => {
+  if (_.has("kv")(v)) {
+    return { ...v.kv, ...v.optv, modifier: _.nth(index)(value_modifier) };
+  }
+
+  return _.map.convert({ cap: false })((v, i) => {
+    return convert(v, i, value_modifier);
+  })(v);
+};
+
+const valuesFromKeys = (values, keys, optionalKeys, value_modifier) =>
+  _.flow(
+    _.map((value) => {
+      return Array.isArray(value?.fields)
+        ? _.map((innerValue) => pick(innerValue, keys, optionalKeys))(
+            value?.fields
+          )
+        : pick(value, keys, optionalKeys);
+    }),
+    (v) => filterNilOrEmpties(v, keys),
+    (v) => convert(v, 0, value_modifier)
+  )(values);
+
+export const getValues = ({ value = [], operator = {}, value_modifier }) => {
+  const defaultOrValue = value || [];
+  return ["field", "field_list"].includes(operator?.value_type)
+    ? valuesFromKeys(
+        defaultOrValue,
+        ["name"],
+        ["path", "metadata", "id", "type", "parent_index"],
+        value_modifier
+      )
+    : valuesFromKeys(defaultOrValue, ["raw"], [], value_modifier);
+};
+
+const OperatorMessage = ({ operator }) =>
+  _.negate(_.isNil)(_.prop("name")(operator)) ? (
+    <FormattedMessage
+      id={`ruleImplementation.operator.${_.prop("name")(operator)}`}
+      defaultMessage={_.prop("name")(operator)}
+    >
+      {(message) => <span className="highlighted">{`"${message}"`}</span>}
+    </FormattedMessage>
+  ) : null;
+
+OperatorMessage.propTypes = {
+  operator: PropTypes.object,
+};
+
+const qualifySqlIdentifier = ({ aliasArray, value }) =>
+  _.flow(
+    _.find({ index: value?.parent_index }),
+    _.propOr(null, "text"),
+    _.defaultTo(value?.metadata?.table || _.last(value?.path)),
+    (qualifier) => (qualifier ? `(${qualifier}).${value?.name}` : value?.name)
+  )(aliasArray);
+
+export const ConditionCell = ({
+  row,
+  alias,
+  validationPopulationCondition,
+}) => {
+  const values = getValues(row);
+  const operator = _.prop("operator")(row);
+  const { formatMessage } = useIntl();
+  return (
+    <>
+      <Table.Row
+        className={
+          validationPopulationCondition ? "validation-population-condition" : ""
+        }
+      >
+        <Table.Cell width={5}>
+          {row?.structure && (
+            <>
+              {validationPopulationCondition ? (
+                <Icon className="filter" />
+              ) : null}
+              {
+                <QualifyAndLinkStructure
+                  value={row.structure}
+                  aliasArray={alias}
+                />
+              }
+              {row?.modifier && (
+                <>
+                  <div className="smaller">
+                    <FormattedMessage
+                      id={`filtersGrid.field.modifier.${row.modifier.name}`}
+                      defaultMessage={row.modifier.name}
+                    />
+                  </div>
+                  {_.flow(
+                    _.prop("modifier.params"),
+                    _.toPairs,
+                    _.map(([paramName, paramValue]) => (
+                      <div key={paramName} className="smaller">
+                        {`${formatMessage({
+                          id: `filtersGrid.field.modifier.${row.modifier.name}.${paramName}`,
+                          defaultMessage: paramName,
+                        })}:`}
+                        {_.isArray(paramValue)
+                          ? paramValue.map((paramValueItem, i) =>
+                              paramValueItem?.id ||
+                              paramValueItem?.data_structure_id ||
+                              paramValueItem?.type ? (
+                                <QualifyAndLinkStructure
+                                  key={`${paramName}_${i}`}
+                                  value={paramValueItem}
+                                  aliasArray={alias}
+                                />
+                              ) : (
+                                <div key={`${paramName}_${i}`}>
+                                  `${paramValueItem}`
+                                </div>
+                              )
+                            )
+                          : `${paramValue}`}
+                      </div>
+                    ))
+                  )(row)}
+                </>
+              )}
+            </>
+          )}
+        </Table.Cell>
+        <Table.Cell width={5}>
+          {operator && <OperatorMessage operator={operator} />}
+        </Table.Cell>
+        <Table.Cell width={5}>
+          {_.map.convert({ cap: false })((value, i) => (
+            <Fragment key={i}>
+              <FormattedLink
+                value={value}
+                operator={operator}
+                aliasArray={alias}
+              />
+              {i + 1 < _.size(values) && (
+                <span>
+                  {" "}
+                  <FormattedMessage id="summary.link.and" />{" "}
+                </span>
+              )}
+              {value?.modifier && (
+                <>
+                  <div className="smaller">
+                    <FormattedMessage
+                      id={`filtersGrid.field.modifier.${value.modifier.name}`}
+                      defaultMessage={value.modifier.name}
+                    />
+                  </div>
+                  {_.flow(
+                    _.prop("modifier.params"),
+                    _.toPairs,
+                    _.map(([paramName, paramValue]) => (
+                      <div key={paramName} className="smaller">
+                        {`${formatMessage({
+                          id: `filtersGrid.field.modifier.${value.modifier.name}.${paramName}`,
+                          defaultMessage: paramName,
+                        })}: ${paramValue}`}
+                      </div>
+                    ))
+                  )(value)}
+                </>
+              )}
+            </Fragment>
+          ))(values)}
+        </Table.Cell>
+      </Table.Row>
+      {row?.population
+        ? row.population.map((validationPopulationCondition, i) => (
+            <ConditionCell
+              validationPopulationCondition
+              row={validationPopulationCondition}
+              key={i}
+            />
+          ))
+        : null}
+    </>
+  );
+};
+
+ConditionCell.propTypes = {
+  row: PropTypes.object,
+  alias: PropTypes.array,
+  validationPopulationCondition: PropTypes.bool,
+};
+
+export default ConditionCell;

package/src/components/ConditionSummary.js

@@ -2,286 +2,16 @@ import _ from "lodash/fp";
 import React, { Fragment } from "react";
 import PropTypes from "prop-types";
 import { Divider, Header, Icon, Segment, Table } from "semantic-ui-react";
-import { Link } from "react-router-dom";
 import { FormattedMessage } from "react-intl";
-import { useIntl } from "react-intl";
-import { linkTo } from "@truedat/core/routes";
-
-const concatValues = (values, link) => _.join(link)(values);
-
-const LinkToStructure = ({ value, aliasArray }) =>
-  value?.id ? (
-    <Link to={linkTo.STRUCTURE({ id: value.id })}>
-      <div className="highlighted">
-        {qualifySqlIdentifier({ aliasArray, value })}
-      </div>{" "}
-    </Link>
-  ) : (
-    <span>{value.name}</span>
-  );
-
-LinkToStructure.propTypes = {
-  value: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),
-  aliasArray: PropTypes.array,
-};
-
-const FormattedLink = ({ value, aliasArray, operator = {} }) => {
-  switch (operator?.value_type) {
-    case "field":
-      return <LinkToStructure value={value} aliasArray={aliasArray} />;
-    case "field_list":
-      return (
-        <>
-          {_.map.convert({ cap: false })((v, i) => (
-            <LinkToStructure key={i} value={v} aliasArray={aliasArray} />
-          ))(value)}
-        </>
-      );
-    default:
-      return (
-        <span className="highlighted">
-          <FormattedMessage
-            id={`ruleImplementation.filtersField.${value.raw}`}
-            defaultMessage={`"${
-              _.isArray(value.raw) ? _.join(", ")(value.raw) : value.raw
-            }"`}
-          ></FormattedMessage>
-        </span>
-      );
-  }
-};
-
-FormattedLink.propTypes = {
-  value: PropTypes.oneOfType([PropTypes.object, PropTypes.array]),
-  operator: PropTypes.object,
-  aliasArray: PropTypes.array,
-};
-
-const nilOrEmpty = (v) => _.isNil(v) || v === "";
-
-const filterNilOrEmpties = (values, keys) => {
-  if ("kv" in values) {
-    return _.every((k) => !nilOrEmpty(values.kv[k]))(keys) ? values : null;
-  }
-
-  return _.flow(
-    _.map((v) => filterNilOrEmpties(v, keys)),
-    _.filter((v) => !!v)
-  )(values);
-};
-
-const pick = (value, keys, optionalKeys) => ({
-  kv: _.pick(keys)(value),
-  optv: _.pick(optionalKeys)(value),
-});
-
-const convert = (v, index, value_modifier) => {
-  if (_.has("kv")(v)) {
-    return { ...v.kv, ...v.optv, modifier: _.nth(index)(value_modifier) };
-  }
-
-  return _.map.convert({ cap: false })((v, i) => {
-    return convert(v, i, value_modifier);
-  })(v);
-};
-
-const valuesFromKeys = (values, keys, optionalKeys, value_modifier) =>
-  _.flow(
-    _.map((value) => {
-      return Array.isArray(value?.fields)
-        ? _.map((innerValue) => pick(innerValue, keys, optionalKeys))(
-            value?.fields
-          )
-        : pick(value, keys, optionalKeys);
-    }),
-    (v) => filterNilOrEmpties(v, keys),
-    (v) => convert(v, 0, value_modifier)
-  )(values);
+import ConditionCell from "./ConditionCell";
 
 export const empty = (rows) =>
   rows && _.every((r) => _.isEmpty(r) || _.isNil(r))(rows);
 
-export const getValues = ({ value = [], operator = {}, value_modifier }) => {
-  const defaultOrValue = value || [];
-  return ["field", "field_list"].includes(operator?.value_type)
-    ? valuesFromKeys(
-        defaultOrValue,
-        ["name"],
-        ["path", "metadata", "id", "type", "parent_index"],
-        value_modifier
-      )
-    : valuesFromKeys(defaultOrValue, ["raw"], [], value_modifier);
-};
-
 export const path = ({ name, path = [] }) =>
   concatValues([...path, name], " > ");
 
-const OperatorMessage = ({ operator }) =>
-  _.negate(_.isNil)(_.prop("name")(operator)) ? (
-    <FormattedMessage
-      id={`ruleImplementation.operator.${_.prop("name")(operator)}`}
-      defaultMessage={_.prop("name")(operator)}
-    >
-      {(message) => <span className="highlighted">{`"${message}"`}</span>}
-    </FormattedMessage>
-  ) : null;
-
-OperatorMessage.propTypes = {
-  operator: PropTypes.object,
-};
-
-const qualifySqlIdentifier = ({ aliasArray, value }) =>
-  _.flow(
-    _.find({ index: value?.parent_index }),
-    _.propOr(null, "text"),
-    _.defaultTo(value?.metadata?.table || _.last(value?.path)),
-    (qualifier) => (qualifier ? `(${qualifier}).${value?.name}` : value?.name)
-  )(aliasArray);
-
-const ConditionCell = ({ row, alias, validationPopulationCondition }) => {
-  const values = getValues(row);
-  const operator = _.prop("operator")(row);
-  const { formatMessage } = useIntl();
-  return (
-    <>
-      <Table.Row
-        className={
-          validationPopulationCondition ? "validation-population-condition" : ""
-        }
-      >
-        <Table.Cell width={5}>
-          {_.has("structure")(row) && (
-            <>
-              {_.path("structure.id")(row) ? (
-                <>
-                  {validationPopulationCondition ? (
-                    <Icon className="filter" />
-                  ) : null}
-                  <Link
-                    to={linkTo.STRUCTURE({
-                      id: _.path("structure.id")(row),
-                    })}
-                  >
-                    <span className="highlighted">
-                      {qualifySqlIdentifier({
-                        aliasArray: alias,
-                        value: row.structure,
-                      })}
-                    </span>
-                  </Link>
-                </>
-              ) : (
-                <span>{_.path("structure.name")(row)}</span>
-              )}
-              {row?.modifier && (
-                <>
-                  <div className="smaller">
-                    <FormattedMessage
-                      id={`filtersGrid.field.modifier.${row.modifier.name}`}
-                      defaultMessage={row.modifier.name}
-                    />
-                  </div>
-                  {_.flow(
-                    _.prop("modifier.params"),
-                    _.toPairs,
-                    _.map(([paramName, paramValue]) => (
-                      <div key={paramName} className="smaller">
-                        {`${formatMessage({
-                          id: `filtersGrid.field.modifier.${row.modifier.name}.${paramName}`,
-                          defaultMessage: paramName,
-                        })}:`}
-                        {_.isArray(paramValue)
-                          ? paramValue.map((row, i) =>
-                              _.isObject(row) ? (
-                                _.path("data_structure_id")(row) ? (
-                                  <Link
-                                    key={i}
-                                    to={linkTo.STRUCTURE({
-                                      id: _.path("data_structure_id")(row),
-                                    })}
-                                  >
-                                    <span className="highlighted">
-                                      {qualifySqlIdentifier({
-                                        aliasArray: alias,
-                                        value: row,
-                                      })}
-                                    </span>
-                                  </Link>
-                                ) : (
-                                  <span key={i}>{_.path("name")(row)}</span>
-                                )
-                              ) : null
-                            )
-                          : `${paramValue}`}
-                      </div>
-                    ))
-                  )(row)}
-                </>
-              )}
-            </>
-          )}
-        </Table.Cell>
-        <Table.Cell width={5}>
-          {operator && <OperatorMessage operator={operator} />}
-        </Table.Cell>
-        <Table.Cell width={5}>
-          {_.map.convert({ cap: false })((value, i) => (
-            <Fragment key={i}>
-              <FormattedLink
-                value={value}
-                operator={operator}
-                aliasArray={alias}
-              />
-              {i + 1 < _.size(values) && (
-                <span>
-                  {" "}
-                  <FormattedMessage id="summary.link.and" />{" "}
-                </span>
-              )}
-              {value?.modifier && (
-                <>
-                  <div className="smaller">
-                    <FormattedMessage
-                      id={`filtersGrid.field.modifier.${value.modifier.name}`}
-                      defaultMessage={value.modifier.name}
-                    />
-                  </div>
-                  {_.flow(
-                    _.prop("modifier.params"),
-                    _.toPairs,
-                    _.map(([paramName, paramValue]) => (
-                      <div key={paramName} className="smaller">
-                        {`${formatMessage({
-                          id: `filtersGrid.field.modifier.${value.modifier.name}.${paramName}`,
-                          defaultMessage: paramName,
-                        })}: ${paramValue}`}
-                      </div>
-                    ))
-                  )(value)}
-                </>
-              )}
-            </Fragment>
-          ))(values)}
-        </Table.Cell>
-      </Table.Row>
-      {row?.population
-        ? row.population.map((validationPopulationCondition, i) => (
-            <ConditionCell
-              validationPopulationCondition
-              row={validationPopulationCondition}
-              key={i}
-            />
-          ))
-        : null}
-    </>
-  );
-};
-
-ConditionCell.propTypes = {
-  row: PropTypes.object,
-  alias: PropTypes.array,
-  validationPopulationCondition: PropTypes.bool,
-};
+const concatValues = (values, link) => _.join(link)(values);
 
 export const ConditionSummary = ({ rows, type, icon, alias }) => {
   const areMultidimensionalRows =

package/src/components/FieldSummary.js

@@ -5,44 +5,11 @@ import { Header, Icon, Segment, Table } from "semantic-ui-react";
 import { Link } from "react-router-dom";
 import { FormattedMessage } from "react-intl";
 import { linkTo } from "@truedat/core/routes";
+import ConditionCell from "./ConditionCell";
 
 export const empty = (rows) =>
   rows && _.every((r) => _.isEmpty(r) || _.isNil(r))(rows);
 
-const ConditionCell = ({ row, alias }) => {
-  const alias_text = _.flow(
-    _.find({ index: row.structure?.parent_index }),
-    _.propOr(null, "text")
-  )(alias);
-
-  return (
-    <Table.Row>
-      <Table.Cell width={5}>
-        {_.has("structure")(row) &&
-          (_.prop("structure.id")(row) ? (
-            <Link
-              to={linkTo.STRUCTURE({
-                id: _.path("structure.id")(row),
-              })}
-            >
-              <span className="highlighted">
-                {alias_text && `(${alias_text}).`}{" "}
-                {`"${_.pathOr("", "structure.name")(row)}"`}
-              </span>
-            </Link>
-          ) : (
-            <span>{_.prop("structure.name")(row)}</span>
-          ))}
-      </Table.Cell>
-    </Table.Row>
-  );
-};
-
-ConditionCell.propTypes = {
-  row: PropTypes.object,
-  alias: PropTypes.array,
-};
-
 export const FieldSummary = ({ rows, type, icon, alias }) => {
   const wrappedRows = [rows];
   return empty(rows) ? null : (

package/src/components/__tests__/ImplementationSummary.spec.js

@@ -1,7 +1,7 @@
 import React from "react";
 import { shallow } from "enzyme";
 import { render } from "@truedat/test/render";
-import { getValues } from "../ConditionSummary";
+import { getValues } from "../ConditionCell";
 import { ImplementationSummary } from "../ImplementationSummary";
 
 const renderOpts = {

package/src/components/__tests__/__snapshots__/ConditionSummary.spec.js.snap

@@ -56,11 +56,12 @@ exports[`<ConditionSummary /> matches the latest snapshot 1`] = `
             <a
               href="/structures/2598"
             >
-              <span
+              <div
                 class="highlighted"
               >
                 (foo_alias).Mes
-              </span>
+              </div>
+               
             </a>
           </td>
           <td

package/src/components/__tests__/__snapshots__/ImplementationSummary.spec.js.snap

@@ -263,11 +263,12 @@ exports[`<ImplementationSummary /> displays correctly validations values of list
             <a
               href="/structures/2598"
             >
-              <span
+              <div
                 class="highlighted"
               >
                 Mes
-              </span>
+              </div>
+               
             </a>
           </td>
           <td

package/src/components/__tests__/__snapshots__/NewRuleImplementation.spec.js.snap

@@ -626,11 +626,12 @@ exports[`<NewRuleImplementation /> calculate aliases when not informed 1`] = `
                 <a
                   href="/structures/4817544"
                 >
-                  <span
+                  <div
                     class="highlighted"
                   >
                     (table2).descripcion
-                  </span>
+                  </div>
+                   
                 </a>
               </td>
               <td
@@ -714,11 +715,12 @@ exports[`<NewRuleImplementation /> calculate aliases when not informed 1`] = `
                 <a
                   href="/structures/4814766"
                 >
-                  <span
+                  <div
                     class="highlighted"
                   >
                     (FS).agent
-                  </span>
+                  </div>
+                   
                 </a>
               </td>
               <td
@@ -787,15 +789,20 @@ exports[`<NewRuleImplementation /> calculate aliases when not informed 1`] = `
                 <a
                   href="/structures/4814766"
                 >
-                  <span
+                  <div
                     class="highlighted"
                   >
-                    (FS).
-                     
-                    "agent"
-                  </span>
+                    (FS).agent
+                  </div>
+                   
                 </a>
               </td>
+              <td
+                class="five wide"
+              />
+              <td
+                class="five wide"
+              />
             </tr>
           </tbody>
         </table>

package/src/components/index.js

@@ -1,4 +1,5 @@
 import ConceptRules from "./ConceptRules";
+import ConditionCell from "./ConditionCell";
 import EditRule from "./EditRule";
 import RuleResultDetails from "./RuleResultDetails";
 import ExecutionGroup from "./ExecutionGroup";
@@ -21,6 +22,7 @@ import RulesLoader from "./RulesLoader";
 
 export {
   ConceptRules,
+  ConditionCell,
   EditRule,
   RuleResultDetails,
   ExecutionGroup,

package/src/components/ruleImplementationForm/FieldsGrid.js

@@ -15,7 +15,9 @@ export const FieldsGrid = ({ rows, setRowValue, structures }) => {
 
   const onStructureChange = (index, value) => {
     const structure = {
-      ..._.pick(["field_type", "name", "parent_index", "type"])(value),
+      ..._.pick(["field_type", "name", "parent_index", "type", "metadata"])(
+        value
+      ),
       id: value.data_structure_id,
     };
     setRowValue({

package/src/components/ruleImplementationForm/FiltersFormGroup.js

@@ -102,6 +102,7 @@ export const FiltersFormGroup = ({
             </Dropdown>
           ) : null}
         </div>
+
         {selectedModifier ? (
           <FieldModifier
             modifier={selectedModifier}

package/src/messages/en.js

@@ -572,10 +572,10 @@ export default {
     "The implementation has not changed",
   "ruleImplementations.upload.failed.header":
     "Error uploading file. No rules have been created.",
-  "ruleImplementations.upload.failed.misssing_required_columns":
-    "Faltan columnas obligatorias en el fichero. Esperado [{expected}]. Recibido [{found}].",
+  "ruleImplementations.upload.failed.missing_required_columns":
+    "Missing required columns. Expected [{expected}]. Found [{found}].",
   "ruleImplementations.upload.success.errors":
-    "Error in {implementation_key} attribute: {key} message: {message} ",
+    "Error in {implementation_key} attribute: {key} message: {message}",
   "ruleImplementations.upload.success.header":
     "Upload success! Loaded {count_ids} omitted {count_errors}",
   "ruleResult": "Rule execution result",
@@ -614,10 +614,10 @@ export default {
   "rules.searching": "Searching...",
   "rules.upload.failed.header":
     "Error uploading file. No rules have been created.",
-  "rules.upload.failed.misssing_required_columns":
+  "rules.upload.failed.missing_required_columns":
     "Missing required columns. Expected [{expected}]. Found [{found}].",
   "rules.upload.success.errors":
-    "Error in {rule_name} attribute: {key} message: {message} ",
+    "Error in {rule_name} attribute: {key} message: {message}",
   "rules.upload.success.header":
     "Upload successful! Loaded {count_ids} omitted {count_errors}",
   "segmentsForm.add.text": "Add Segment",

package/src/messages/es.js

@@ -593,10 +593,10 @@ export default {
     "La implementación no ha cambiado",
   "ruleImplementations.upload.failed.header":
     "Error al subir el fichero. No se ha realizado ninguna inserción.",
-  "ruleImplementations.upload.failed.misssing_required_columns":
+  "ruleImplementations.upload.failed.missing_required_columns":
     "Faltan columnas obligatorias en el fichero. Esperado [{expected}]. Recibido [{found}].",
   "ruleImplementations.upload.success.errors":
-    "Error en {name} atributo: {key} mensaje: {message} ",
+    "Error en {implementation_key} atributo: {key} mensaje: {message}",
   "ruleImplementations.upload.success.header":
     "¡Fichero subido correctamente! subidos {count_ids} errores {count_errors}",
   "ruleResult": "Resultado de ejecución de regla",
@@ -636,10 +636,10 @@ export default {
   "rules.searching": "Buscando...",
   "rules.upload.failed.header":
     "Error al subir el fichero. No se ha realizado ninguna inserción.",
-  "rules.upload.failed.misssing_required_columns":
+  "rules.upload.failed.missing_required_columns":
     "Faltan columnas obligatorias en el fichero. Esperado [{expected}]. Recibido [{found}].",
   "rules.upload.success.errors":
-    "Error en {rule_name} atributo: {key} mensaje: {message} ",
+    "Error en {rule_name} atributo: {key} mensaje: {message}",
   "rules.upload.success.header":
     "¡Fichero subido correctamente! subidos {count_ids} errores {count_errors}",
   "segmentsForm.add.text": "Añadir segmentación",

package/src/reducers/dqMessage.js

@@ -61,12 +61,12 @@ const dqMessage = (state = initialState, { type, payload }) => {
       const messagesImp = _.has("errors")(payload.data)
         ? _.flow(
             _.propOr([], "errors"),
-            _.map((error) => ({
+            _.map(({ implementation_key, message }) => ({
               id: "ruleImplementations.upload.success.errors",
               fields: {
-                name: error.implementation_key,
-                key: Object.keys(error.message)[0],
-                message: error.message[Object.keys(error.message)[0]][0],
+                implementation_key,
+                key: Object.keys(message)[0],
+                message: message[Object.keys(message)[0]][0],
               },
               defaultMessage:
                 "ruleImplementations.upload.success.errors.default",