@truedat/dq 4.56.5 → 4.56.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [4.56.7] 2022-11-28
+
+### Added
+
+- # [TD-4179] inserted_at and updated_at columns on Implementations
+
+## [4.56.6] 2022-11-28
+
+### Added
+
+- [TD-5247] FieldSummary and reference dataset table name
+
 ## [4.56.5] 2022-11-28
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.56.5",
+  "version": "4.56.7",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -22,26 +22,25 @@
     "eslint:fix": "eslint --fix src/**"
   },
   "devDependencies": {
-    "@babel/cli": "^7.17.10",
-    "@babel/core": "^7.18.0",
-    "@babel/plugin-proposal-class-properties": "^7.17.12",
-    "@babel/plugin-proposal-object-rest-spread": "^7.18.0",
-    "@babel/plugin-proposal-optional-chaining": "^7.17.12",
+    "@babel/cli": "^7.19.3",
+    "@babel/core": "^7.20.5",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-object-rest-spread": "^7.20.2",
+    "@babel/plugin-proposal-optional-chaining": "^7.18.9",
     "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-    "@babel/plugin-transform-modules-commonjs": "^7.18.0",
-    "@babel/preset-env": "^7.18.0",
-    "@babel/preset-react": "^7.17.12",
-    "@testing-library/jest-dom": "^5.16.4",
+    "@babel/plugin-transform-modules-commonjs": "^7.19.6",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-react": "^7.18.6",
+    "@testing-library/jest-dom": "^5.16.5",
     "@testing-library/react": "^12.0.0",
     "@testing-library/user-event": "^13.2.1",
-    "@truedat/test": "4.56.5",
+    "@truedat/test": "4.56.7",
     "babel-jest": "^28.1.0",
     "babel-plugin-dynamic-import-node": "^2.3.3",
     "babel-plugin-lodash": "^3.3.4",
     "babel-plugin-react-intl": "^5.1.18",
     "babel-plugin-transform-semantic-ui-react-imports": "^1.4.1",
     "enzyme": "^3.11.0",
-    "enzyme-adapter-react-16": "^1.15.6",
     "enzyme-to-json": "^3.6.2",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^28.1.0",
@@ -50,7 +49,7 @@
     "react-dom": "^16.14.0",
     "redux-saga-test-plan": "^4.0.4",
     "rimraf": "^3.0.2",
-    "semantic-ui-react": "^2.0.3"
+    "semantic-ui-react": "^2.1.4"
   },
   "jest": {
     "maxWorkers": "50%",
@@ -92,10 +91,11 @@
     ]
   },
   "dependencies": {
-    "@apollo/client": "^3.7.0",
-    "@truedat/core": "4.56.5",
-    "@truedat/df": "4.56.5",
+    "@apollo/client": "^3.7.1",
+    "@truedat/core": "4.56.7",
+    "@truedat/df": "4.56.7",
     "graphql": "^15.5.3",
+    "moment": "^2.29.4",
     "path-to-regexp": "^1.7.0",
     "prop-types": "^15.8.1",
     "rc-slider": "^8.6.1",
@@ -104,15 +104,16 @@
     "react-redux": "^7.2.4",
     "react-router-dom": "^5.2.0",
     "redux": "^4.1.1",
-    "redux-saga": "^1.1.3",
+    "redux-saga": "^1.2.1",
     "redux-saga-routines": "^3.2.3",
-    "reselect": "^4.0.0",
-    "semantic-ui-calendar-react": "^0.15.3"
+    "reselect": "^4.1.7",
+    "semantic-ui-calendar-react": "^0.15.3",
+    "semantic-ui-react": "^2.1.4"
   },
   "peerDependencies": {
     "react": ">= 16.8.6 < 17",
     "react-dom": ">= 16.8.6 < 17",
-    "semantic-ui-react": ">= 0.88.2 < 2.1"
+    "semantic-ui-react": ">= 2.0.3 < 2.2"
   },
-  "gitHead": "004b5727c2454992c5c8a3e93de617b7dbb86009"
+  "gitHead": "e321b6e541c2205813236081e4c9c5eab34f0007"
 }

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__/__fixtures__/NewRuleImplementationProps.js

@@ -122,7 +122,7 @@ export const newRuleImplementationProps = {
           },
           type: "Table",
         },
-        join_type: "inner"
+        join_type: "inner",
       },
     ],
     deleted_at: null,

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/DatasetForm.js

@@ -58,8 +58,15 @@ export const DatasetForm = ({
     });
   };
 
-  const getStructureAttrs = (structure) =>
-    _.pick(["id", "name", "path", "system", "type", "headers"])(structure);
+  const getStructureAttrs = ({
+    id,
+    name,
+    original_name,
+    path,
+    system,
+    type,
+    headers,
+  }) => ({ id, name: original_name || name, path, system, type, headers });
 
   const hasChangedStructure = (index, value) =>
     _.path("structure.id")(value) !==

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

@@ -537,6 +537,7 @@ export default {
     "Implementation template",
   "ruleImplementations.props.implementation_type": "Type",
   "ruleImplementations.props.inserted_at": "Inserted at",
+  "ruleImplementations.props.updated_at": "Updated at",
   "ruleImplementations.props.last_change_at": "Last change at",
   "ruleImplementations.props.last_execution_at": "Last Execution",
   "ruleImplementations.props.minimum": "Threshold",

package/src/messages/es.js

@@ -553,6 +553,7 @@ export default {
     "Plantilla de implementación",
   "ruleImplementations.props.implementation_type": "Tipo",
   "ruleImplementations.props.inserted_at": "Insertado",
+  "ruleImplementations.props.updated_at": "Actualizado",
   "ruleImplementations.props.last_change_at": "Fecha de última modificación",
   "ruleImplementations.props.last_execution_at": "Última ejecución",
   "ruleImplementations.props.minimum": "Valor umbral",

package/src/reducers/ruleImplementations.js

@@ -20,6 +20,8 @@ const pickFields = _.pick([
   "results",
   "event_type",
   "event_inserted_at",
+  "inserted_at",
+  "updated_at",
   "deleted_at",
   "result_type",
   "minimum",

package/src/selectors/getRuleImplementationColumns.js

@@ -91,6 +91,16 @@ export const defaultImplementationColumns = [
     sort: { name: "execution_result_info.result" },
     width: 2,
   },
+  {
+    name: "inserted_at",
+    fieldSelector: ({ inserted_at }) => ({ value: inserted_at }),
+    fieldDecorator: DateTime,
+  },
+  {
+    name: "updated_at",
+    fieldSelector: ({ updated_at }) => ({ value: updated_at }),
+    fieldDecorator: DateTime,
+  },
 ];
 
 const getColumns = (state) => state.ruleImplementationColumns;