@truedat/dq 4.37.1 → 4.37.5

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [4.37.5] 2022-02-06
+
+### Changed
+
+- [TD-4426]
+  - On `ExecutionDetails` decode detail fields with prefix `base64_`
+  - Option to create messages with `ruleResult.details.props.<field_name>` to replace detail key
+
+## [4.37.4] 2022-02-04
+
+### Changed
+
+- [TD-4424] Disable user filters while rule filters are loading
+
+## [4.37.3] 2022-02-03
+
+### Added
+
+- [TD-2929] Added support for `UserSearchFilters` on `Rules` and `RuleImplementations`
+
+## [4.37.2] 2022-02-02
+
+### Added
+
+- [TD-4294] Rule audit tab
+
 ## [4.37.1] 2022-02-02
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.37.1",
+  "version": "4.37.5",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -82,8 +82,8 @@
   },
   "dependencies": {
     "@apollo/client": "^3.4.10",
-    "@truedat/core": "4.37.1",
-    "@truedat/df": "4.37.1",
+    "@truedat/core": "4.37.5",
+    "@truedat/df": "4.37.5",
     "axios": "^0.19.2",
     "graphql": "^15.5.3",
     "path-to-regexp": "^1.7.0",
@@ -103,5 +103,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 0.88.2 < 2.1"
   },
-  "gitHead": "36ffd7e86efe27f38c3ae1bb616eb9eb4d444d12"
+  "gitHead": "98ff8669e99824ef1bdbd3d12035e6371029e4ca"
 }

package/src/components/ExecutionDetails.js

@@ -28,7 +28,7 @@ const GeneralInformation = ({ ruleImplementation, ruleResult }) => {
 
       <Table.Row>
         <Table.Cell>
-          {formatMessage({ id: "ruleResult.props.date" })}{" "}
+          {formatMessage({ id: "ruleResult.props.date" })}
         </Table.Cell>
         <Table.Cell>
           <DateTime value={ruleResult.date} />
@@ -37,14 +37,14 @@ const GeneralInformation = ({ ruleImplementation, ruleResult }) => {
 
       <Table.Row>
         <Table.Cell>
-          {formatMessage({ id: "ruleResult.props.records" })}{" "}
+          {formatMessage({ id: "ruleResult.props.records" })}
         </Table.Cell>
         <Table.Cell>{formatNumber(ruleResult.records)}</Table.Cell>
       </Table.Row>
 
       <Table.Row>
         <Table.Cell>
-          {formatMessage({ id: "ruleResult.props.errors" })}{" "}
+          {formatMessage({ id: "ruleResult.props.errors" })}
         </Table.Cell>
         <Table.Cell>{formatNumber(ruleResult.errors)}</Table.Cell>
       </Table.Row>
@@ -58,13 +58,19 @@ GeneralInformation.propTypes = {
 };
 
 const DetailRow = ({ details }) => {
+  const { formatMessage } = useIntl();
   return _.flow(
     _.keys,
     _.map((key) => (
       <Table.Row key={key}>
-        <Table.Cell>{key}</Table.Cell>
         <Table.Cell>
-          {key === "Query"
+          {formatMessage({
+            id: `ruleResult.details.props.${key.replace(/^(base64_)/, "")}`,
+            defaultMessage: key.replace(/^(base64_)/, ""),
+          })}
+        </Table.Cell>
+        <Table.Cell>
+          {key === "Query" || key.startsWith("base64_")
             ? Buffer.from(details[key], "base64").toString()
             : JSON.stringify(details[key], null, 2)}
         </Table.Cell>
@@ -73,11 +79,13 @@ const DetailRow = ({ details }) => {
   )(details);
 };
 
-export const ExecutionDetails = ({ ruleImplementation, rule_result_id }) => {
+DetailRow.propTypes = { details: PropTypes.object };
+
+export const ExecutionDetails = ({ ruleImplementation, ruleResultId }) => {
   const { formatMessage } = useIntl();
-  const { rule_result_id: id } = useParams();
+  const { rule_result_id: paramsId } = useParams();
 
-  const result_id = _.defaultTo(_.toNumber(id))(rule_result_id);
+  const result_id = _.defaultTo(_.toNumber(paramsId))(ruleResultId);
 
   const ruleResult = _.find(_.propEq("id", result_id))(
     ruleImplementation.results
@@ -128,7 +136,7 @@ export const ExecutionDetails = ({ ruleImplementation, rule_result_id }) => {
 
 ExecutionDetails.propTypes = {
   ruleImplementation: PropTypes.object,
-  rule_result_id: PropTypes.number,
+  ruleResultId: PropTypes.number,
 };
 
 const mapStateToProps = (state) => ({

package/src/components/ImplementationsRoutes.js

@@ -8,6 +8,9 @@ import RuleImplementationsLoader from "./RuleImplementationsLoader";
 const TemplatesLoader = React.lazy(() =>
   import("@truedat/df/templates/components/TemplatesLoader")
 );
+const UserSearchFiltersLoader = React.lazy(() =>
+  import("@truedat/dd/components/UserSearchFiltersLoader")
+);
 
 const ImplementationsRoutes = () => (
   <Route
@@ -17,6 +20,7 @@ const ImplementationsRoutes = () => (
         <RuleImplementationsLoader />
         <ImplementationFiltersLoader />
         <TemplatesLoader scope="qe" />
+        <UserSearchFiltersLoader scope="rule_implementation" />
         <RuleImplementations exact />
       </>
     )}

package/src/components/RuleEventRow.js

@@ -0,0 +1,47 @@
+import _ from "lodash/fp";
+import React from "react";
+import PropTypes from "prop-types";
+import { Feed } from "semantic-ui-react";
+import { useIntl } from "react-intl";
+import Moment from "react-moment";
+
+export const RuleEventRow = ({ user, user_name, ts, payload }) => {
+  const { formatMessage, locale } = useIntl();
+  const userName = _.propOr(user_name, "user_name")(user);
+
+  return _.isEmpty(payload) ? null : (
+    <Feed.Event>
+      <Feed.Content>
+        <Feed.Summary>
+          <Feed.User>{userName}</Feed.User>{" "}
+          <Feed.Date>
+            <Moment locale={locale} date={ts} format="YYYY-MM-DD HH:mm" />
+          </Feed.Date>
+        </Feed.Summary>
+        {payload.map(({ field, action, value }, i) => (
+          <Feed.Extra
+            key={i}
+            text
+            content={formatMessage(
+              {
+                id: `rules.events.action_${action}${
+                  typeof value === "undefined" || _.isObject(value) ? "" : "_to"
+                }`,
+              },
+              [field, JSON.stringify(value)]
+            )}
+          />
+        ))}
+      </Feed.Content>
+    </Feed.Event>
+  );
+};
+
+RuleEventRow.propTypes = {
+  user: PropTypes.object,
+  user_name: PropTypes.string,
+  ts: PropTypes.string,
+  payload: PropTypes.array,
+};
+
+export default RuleEventRow;

package/src/components/RuleEvents.js

@@ -0,0 +1,31 @@
+import React from "react";
+import PropTypes from "prop-types";
+import { Feed, Segment } from "semantic-ui-react";
+import { connect } from "react-redux";
+import { getParsedEvents } from "../selectors";
+import { RuleEventRow } from "./RuleEventRow";
+
+export const RuleEvents = ({ events, eventsLoading }) => {
+  return eventsLoading ? null : (
+    <Segment attached="bottom">
+      <Feed size="small">
+        {events.map((e, i) => (
+          <RuleEventRow key={i} {...e} />
+        ))}
+      </Feed>
+    </Segment>
+  );
+};
+RuleEvents.propTypes = {
+  events: PropTypes.array.isRequired,
+  eventsLoading: PropTypes.bool,
+};
+
+const mapStateToProps = (state) => {
+  return {
+    events: getParsedEvents(state),
+    eventsLoading: state.eventsLoading,
+  };
+};
+
+export default connect(mapStateToProps)(RuleEvents);

package/src/components/RuleImplementationSelectedFilters.js

@@ -4,6 +4,11 @@ import { connect } from "react-redux";
 import { injectIntl } from "react-intl";
 import { makeOption } from "@truedat/core/services/i18n";
 import { SelectedFilters } from "@truedat/core/components";
+import {
+  applyUserSearchFilter,
+  deleteUserSearchFilter,
+  saveUserSearchFilters,
+} from "@truedat/dd/routines";
 import {
   closeImplementationFilter,
   openImplementationFilter,
@@ -24,29 +29,46 @@ const translations = (formatMessage) => ({
 
 export const mapStateToProps = (state, ownProps) => {
   const formatMessage = _.pathOr(_.prop("id"), "intl.formatMessage")(ownProps);
-  const { ruleImplementationSelectedFilter: selectedFilter } = state;
+  const {
+    ruleImplementationFiltersLoading: loading,
+    ruleImplementationSelectedFilter: selectedFilter,
+  } = state;
   const i18nValues = _.flow(
     getRuleImplementationSelectedFilterValues,
     _.map(makeOption(translations(formatMessage), selectedFilter))
   )(state);
 
+  const {
+    selectedUserSearchFilter: selectedUserFilter,
+    ruleImplementationActiveFilters: activeFilters,
+    userSearchFilters: userFilters,
+  } = state;
+
   return {
+    loading,
     selectedFilter,
     selectedFilters: getRuleImplementationSelectedFilters(state),
     selectedFilterActiveValues:
       getRuleImplementationSelectedFilterActiveValues(state),
     selectedFilterValues: i18nValues,
+    selectedUserFilter,
+    activeFilters,
+    userFilters,
+    userFilterScope: "rule_implementation",
   };
 };
 
 const mapDispatchToProps = (dispatch) =>
   bindActionCreators(
     {
+      applyUserFilter: applyUserSearchFilter,
       closeFilter: closeImplementationFilter,
+      deleteUserFilter: deleteUserSearchFilter,
       openFilter: openImplementationFilter,
       removeFilter: removeImplementationFilter,
       resetFilters: resetImplementationFilters,
       toggleFilterValue: toggleImplementationFilterValue,
+      saveFilters: saveUserSearchFilters,
     },
     dispatch
   );

package/src/components/RuleRoutes.js

@@ -9,6 +9,7 @@ import { useAuthorized } from "@truedat/core/hooks";
 import {
   RULE,
   RULE_EDIT,
+  RULE_EVENTS,
   RULE_IMPLEMENTATION_RESULT_DETAILS,
   RULE_IMPLEMENTATION_RESULTS_DETAILS,
   RULE_IMPLEMENTATION,
@@ -32,6 +33,7 @@ import NewRule from "./NewRule";
 import NewRuleImplementation from "./NewRuleImplementation";
 import Rule from "./Rule";
 import RuleCrumbs from "./RuleCrumbs";
+import RuleEvents from "./RuleEvents";
 import RuleImplementation from "./RuleImplementation";
 import RuleImplementationEvents from "./RuleImplementationEvents";
 import RuleImplementationLoader from "./RuleImplementationLoader";
@@ -61,13 +63,19 @@ const ImplementationStructuresLoader = React.lazy(() =>
 const QualityTemplatesLoader = () => <TemplatesLoader scope="dq" />;
 const ImplementationTemplatesLoader = () => <TemplatesLoader scope="ri" />;
 
+const RuleEventsLoader = () => {
+  const match = useRouteMatch();
+  const id = _.path("params.id")(match);
+  return <EventsLoader resource_id={id} resource_type="rule" />;
+};
+
 const ImplementationEventsLoader = () => {
   const match = useRouteMatch();
   const id = _.path("params.implementation_id")(match);
   return <EventsLoader resource_id={id} resource_type="implementation" />;
 };
 
-const RuleRoutes = ({
+export const RuleRoutes = ({
   ruleLoaded,
   ruleImplementationLoaded,
   implementationStructures,
@@ -135,6 +143,22 @@ const RuleRoutes = ({
                     </>
                   )}
                 />
+
+                <Route
+                  exact
+                  path={RULE_EVENTS}
+                  render={() => (
+                    <>
+                      <RuleCrumbs />
+                      <Segment>
+                        <RuleEventsLoader />
+                        {ruleLoaded && <Rule />}
+                        {ruleLoaded && <RuleEvents />}
+                      </Segment>
+                    </>
+                  )}
+                />
+
                 <Route
                   exact
                   path={RULE_IMPLEMENTATIONS}
@@ -288,7 +312,7 @@ const RuleRoutes = ({
                         <RuleImplementationLoader />
                         {ruleLoaded && ruleImplementationLoaded && (
                           <RuleImplementation>
-                            <ExecutionDetails rule_result_id={latest.id} />
+                            <ExecutionDetails ruleResultId={latest.id} />
                           </RuleImplementation>
                         )}
                       </Segment>

package/src/components/RuleSelectedFilters.js

@@ -4,6 +4,11 @@ import { connect } from "react-redux";
 import { injectIntl } from "react-intl";
 import { makeOption } from "@truedat/core/services/i18n";
 import { SelectedFilters } from "@truedat/core/components";
+import {
+  applyUserSearchFilter,
+  deleteUserSearchFilter,
+  saveUserSearchFilters,
+} from "@truedat/dd/routines";
 import {
   closeRuleFilter,
   openRuleFilter,
@@ -24,28 +29,43 @@ const translations = (formatMessage) => ({
 
 export const mapStateToProps = (state, ownProps) => {
   const formatMessage = _.pathOr(_.prop("id"), "intl.formatMessage")(ownProps);
-  const { ruleSelectedFilter: selectedFilter } = state;
+  const { ruleFiltersLoading: loading, ruleSelectedFilter: selectedFilter } =
+    state;
   const i18nValues = _.flow(
     getRuleSelectedFilterValues,
     _.map(makeOption(translations(formatMessage), selectedFilter))
   )(state);
 
+  const {
+    selectedUserSearchFilter: selectedUserFilter,
+    ruleActiveFilters: activeFilters,
+    userSearchFilters: userFilters,
+  } = state;
+
   return {
+    loading,
     selectedFilter,
     selectedFilters: getRuleSelectedFilters(state),
     selectedFilterActiveValues: getRuleSelectedFilterActiveValues(state),
     selectedFilterValues: i18nValues,
+    selectedUserFilter,
+    activeFilters,
+    userFilters,
+    userFilterScope: "rule",
   };
 };
 
 const mapDispatchToProps = (dispatch) =>
   bindActionCreators(
     {
+      applyUserFilter: applyUserSearchFilter,
       closeFilter: closeRuleFilter,
+      deleteUserFilter: deleteUserSearchFilter,
       openFilter: openRuleFilter,
       removeFilter: removeRuleFilter,
       resetFilters: resetRuleFilters,
       toggleFilterValue: toggleRuleFilterValue,
+      saveFilters: saveUserSearchFilters,
     },
     dispatch
   );

package/src/components/RuleTabs.js

@@ -6,7 +6,12 @@ import { Link } from "react-router-dom";
 import { connect } from "react-redux";
 import { FormattedMessage } from "react-intl";
 import { usePath } from "@truedat/core/hooks";
-import { RULE, RULE_IMPLEMENTATIONS, linkTo } from "@truedat/core/routes";
+import {
+  RULE,
+  RULE_IMPLEMENTATIONS,
+  RULE_EVENTS,
+  linkTo,
+} from "@truedat/core/routes";
 
 const RuleTabs = ({ rule }) => {
   const path = usePath();
@@ -22,12 +27,21 @@ const RuleTabs = ({ rule }) => {
       >
         <FormattedMessage id="tabs.dq.ruleImplementations" />
       </Menu.Item>
+      <Menu.Item
+        active={path === RULE_EVENTS}
+        as={Link}
+        to={linkTo.RULE_EVENTS({
+          id: rule.id,
+        })}
+      >
+        <FormattedMessage id="tabs.dq.rule.audit" />
+      </Menu.Item>
     </Menu>
   );
 };
 
 RuleTabs.propTypes = {
-  rule: PropTypes.object
+  rule: PropTypes.object,
 };
 
 const mapStateToProps = ({ rule }) => ({ rule });

package/src/components/RulesRoutes.js

@@ -13,13 +13,25 @@ const DomainsLoader = React.lazy(() =>
 const TemplatesLoader = React.lazy(() =>
   import("@truedat/df/templates/components/TemplatesLoader")
 );
+const UserSearchFiltersLoader = React.lazy(() =>
+  import("@truedat/dd/components/UserSearchFiltersLoader")
+);
 const QualityTemplatesLoader = () => <TemplatesLoader scope="dq" />;
 
 const RulesRoutes = () => (
   <>
     <Route path={RULES} component={RulesLoader} />
     <Route path={RULES} component={RuleFiltersLoader} />
-    <Route path={RULES} component={Rules} exact />
+    <Route
+      exact
+      path={RULES}
+      render={() => (
+        <>
+          <UserSearchFiltersLoader scope="rule" />
+          <Rules />
+        </>
+      )}
+    />
     <Switch>
       <Route
         exact

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

@@ -11,41 +11,48 @@ jest.mock("react-router-dom", () => ({
 
 const renderOpts = {
   messages: {
-    en: messages.en,
+    en: {
+      ...messages.en,
+      "ruleResult.details.props.test": "TestMessage",
+    },
   },
 };
 
-describe("<ExecutionDetetails>", () => {
-  const rule = {
-    result_type: "percentage",
-    minimum: 50,
-    goal: 100,
-  };
-  const ruleImplementation = {
-    results: [{ foo: "bar", id: 100, details: { Query: "ImZvbyI=" } }],
-  };
-  const customColumns = [{ foo: "bar", name: "foo" }];
-  const props = {
-    rule,
-    ruleImplementation,
-    customColumns,
-  };
-
+describe("<ExecutionDetails>", () => {
   it("matches the lastest snapshot", () => {
+    const props = {
+      ruleImplementation: {
+        results: [{ foo: "bar", id: 100, details: { Query: "ImZvbyI=" } }],
+      },
+    };
     const { container } = render(<ExecutionDetails {...props} />, renderOpts);
     expect(container).toMatchSnapshot();
   });
 
+  it("decodes details with base64 prefix", () => {
+    const props = {
+      ruleImplementation: {
+        results: [
+          {
+            foo: "bar",
+            id: 100,
+            details: {
+              value: "valor",
+              base64_test: "QmFzZTY0X3ZhbHVl", //base64 for Base64_value
+            },
+          },
+        ],
+      },
+    };
+    const { getByText } = render(<ExecutionDetails {...props} />, renderOpts);
+    expect(getByText("TestMessage")).toBeInTheDocument();
+    expect(getByText("Base64_value")).toBeInTheDocument();
+  });
+
   it("without details", () => {
     const propsWithoutDetails = {
-      ...props,
       ruleImplementation: {
-        ...props.ruleImplementation,
-        results: {
-          ..._.map((result) => _.omit(["details"])(result))(
-            props.ruleImplementation.results
-          ),
-        },
+        results: [{ foo: "bar", id: 100 }],
       },
     };
     const { container } = render(

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

@@ -0,0 +1,33 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { RuleEventRow } from "../RuleEventRow";
+
+describe("<RuleEventsRow />", () => {
+  const props = {
+    payload: [
+      {
+        field: "field1",
+        action: "changed",
+        value: "new value",
+      },
+    ],
+    user_name: "some.user@domain.tld",
+    user: {
+      email: "some.user@domain.tld",
+      full_name: "Some User",
+      id: 142,
+      user_name: "some.user@domain.tld",
+    },
+    ts: "2021-09-16T07:36:32.848603Z",
+  };
+  const renderOpts = {
+    messages: {
+      en: { "rules.events.action_changed_to": "Field {0} changed to: {1}" },
+    },
+  };
+
+  it("matches the latest snapshot", () => {
+    const { container } = render(<RuleEventRow {...props} />, renderOpts);
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,64 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { RuleEvents } from "../RuleEvents";
+import { getParsedEvents } from "../../selectors/getParsedEvents";
+
+describe("<RuleEvents />", () => {
+  const events = [
+    {
+      id: 100217,
+      service: "td_dd",
+      resource_id: 777,
+      resource_type: "rule",
+      event: "rule_updated",
+      payload: {
+        domain_id: 140,
+      },
+      user_id: 142,
+      user_name: null,
+      user: {
+        email: "some.user@domain.tld",
+        full_name: "Some User",
+        id: 142,
+        user_name: "some.user@domain.tld",
+      },
+      ts: "2021-09-16T07:36:32.848603Z",
+    },
+    {
+      id: 100436,
+      service: "td_dd",
+      resource_id: 777,
+      resource_type: "rule",
+      event: "rule_updated",
+      payload: {
+        domain_id: 168,
+      },
+      user_id: 171,
+      user_name: null,
+      user: {
+        email: "some.user@domain.tld",
+        full_name: "Some User",
+        id: 171,
+        user_name: "some.user",
+      },
+      ts: "2021-09-16T09:31:03.061864Z",
+    },
+  ];
+  const renderOpts = {
+    messages: {
+      en: {
+        "rules.events.action_created": "Rule created",
+        "rules.events.action_changed": "Field {0} changed: {1}",
+        "rules.events.action_changed_to": "Field {0} changed to: {1}",
+        "rules.events.action_updated": "Rule updated",
+      },
+    },
+  };
+
+  const props = { events: getParsedEvents({ events }), eventsLoading: false };
+
+  it("matches the latest snapshot", () => {
+    const { container } = render(<RuleEvents {...props} />, renderOpts);
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,23 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { RuleRoutes } from "../RuleRoutes";
+
+describe("<RuleRoutes>", () => {
+  const props = {
+    rule: {},
+    implementationStructures: [],
+    ruleLoaded: true,
+    template: {},
+    ruleImplementation: {},
+    ruleImplementationLoaded: true,
+    implementationStructuresLoaded: true,
+    systemsLoading: true,
+    templatesLoaded: true,
+    structuresAliasesLoading: true,
+  };
+
+  it("matches the lastest snapshot", () => {
+    const { container } = render(<RuleRoutes {...props} />, {});
+    expect(container).toMatchSnapshot();
+  });
+});