@truedat/dq 4.47.1 → 4.47.4

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [4.47.4] 2022-06-29
+
+- [TD-4921] Add implementation workflow events
+
+## [4.47.2] 2022-06-24
+
+### Added
+
+- [TD-4920] Implementation results for workflow
+
 ## [4.46.13] 2022-06-21
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.47.1",
+  "version": "4.47.4",
   "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.47.1",
+    "@truedat/test": "4.47.4",
     "babel-jest": "^28.1.0",
     "babel-plugin-dynamic-import-node": "^2.3.3",
     "babel-plugin-lodash": "^3.3.4",
@@ -88,8 +88,8 @@
   },
   "dependencies": {
     "@apollo/client": "^3.6.4",
-    "@truedat/core": "4.47.1",
-    "@truedat/df": "4.47.1",
+    "@truedat/core": "4.47.4",
+    "@truedat/df": "4.47.4",
     "axios": "^0.19.2",
     "graphql": "^15.5.3",
     "path-to-regexp": "^1.7.0",
@@ -110,5 +110,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 0.88.2 < 2.1"
   },
-  "gitHead": "dffde75b85272debd04fb2fe17c2f54f9045f112"
+  "gitHead": "9d38ae9759ce669fe1b459a3ee80c314d33871e0"
 }

package/src/api/queries.js

@@ -14,3 +14,49 @@ export const IMPLEMENTATION_WITH_VERSIONS_QUERY = gql`
     }
   }
 `;
+
+export const IMPLEMENTATION_RESULTS = gql`
+  query Implementation($id: ID!) {
+    implementation(id: $id) {
+      id
+      implementation_key
+      versions {
+        id
+        implementation_key
+        version
+        status
+        minimum
+        goal
+        results {
+          id
+          date
+          details
+          errors
+          has_remediation
+          has_segments
+          params
+          records
+          result
+          result_type
+        }
+      }
+    }
+  }
+`;
+
+export const IMPLEMENTATION_RESULT = gql`
+  query ImplementationResult($id: ID!) {
+    implementationResult(id: $id) {
+      id
+      date
+      details
+      params
+      errors
+      records
+      result
+      result_type
+      has_segments
+      has_remediation
+    }
+  }
+`;

package/src/components/ImplementationCrumbs.js

@@ -8,15 +8,11 @@ import { FormattedMessage } from "react-intl";
 import { RULES, IMPLEMENTATIONS, linkTo } from "@truedat/core/routes";
 import { DateTime } from "@truedat/core/components";
 
-export const ImplementationCrumbs = ({ ruleImplementation }) => {
+export const ImplementationCrumbs = ({ ruleImplementation, ruleResult }) => {
   const { rule_result_id } = useParams();
   const rule = _.get("rule")(ruleImplementation);
 
-  const ruleResultDate = _.flow(
-    _.propOr([], "results"),
-    _.find(_.propEq("id", _.toNumber(rule_result_id))),
-    _.pathOr("0000-00-00 00:00", "date")
-  )(ruleImplementation);
+  const ruleResultDate = _.pathOr("0000-00-00 00:00", "date")(ruleResult);
 
   return (
     <Breadcrumb>
@@ -82,10 +78,10 @@ export const ImplementationCrumbs = ({ ruleImplementation }) => {
 
 ImplementationCrumbs.propTypes = {
   ruleImplementation: PropTypes.object,
+  ruleResult: PropTypes.object,
 };
 
-const mapStateToProps = ({ rule, ruleImplementation }) => ({
-  rule,
+const mapStateToProps = ({ ruleImplementation }) => ({
   ruleImplementation,
 });
 export default connect(mapStateToProps)(ImplementationCrumbs);

package/src/components/ImplementationsRoutes.js

@@ -79,7 +79,6 @@ export const ImplementationsRoutes = ({
   implementationStructures,
   implementationStructuresLoaded,
 }) => {
-  const latest = _.head(ruleImplementation.results);
   const authorized = useAuthorized();
   const { rule_result_id: ruleResultId } = useParams();
   return (
@@ -308,7 +307,7 @@ export const ImplementationsRoutes = ({
                   <Segment>
                     {ruleImplementationLoaded ? (
                       <RuleImplementation>
-                        <RuleImplementationResults ruleResult={latest} />
+                        <RuleImplementationResults />
                       </RuleImplementation>
                     ) : null}
                   </Segment>
@@ -341,7 +340,7 @@ export const ImplementationsRoutes = ({
                   <Segment>
                     {ruleImplementationLoaded ? (
                       <RuleImplementation>
-                        <RuleResultDetails ruleResultId={latest.id} />
+                        <RuleResultDetails />
                       </RuleImplementation>
                     ) : null}
                   </Segment>

package/src/components/RuleImplementationResults.js

@@ -1,12 +1,16 @@
 import _ from "lodash/fp";
 import React from "react";
+import { useParams } from "react-router-dom";
+import { useQuery } from "@apollo/client";
 import PropTypes from "prop-types";
 import { useIntl } from "react-intl";
 import { connect } from "react-redux";
 import { Table, Message, Divider } from "semantic-ui-react";
 import { columnDecorator } from "@truedat/core/services";
 import Moment from "react-moment";
+import { Loading } from "@truedat/core/components";
 import { getRuleResultsColumns } from "../selectors";
+import { IMPLEMENTATION_RESULTS } from "../api/queries";
 import RuleResultRow from "./RuleResultRow";
 
 const optionalColumns = ["errors", "records", "details"];
@@ -22,15 +26,25 @@ export const getCustomColumnsWithData = (ruleResults, columns) =>
 
 export const RuleImplementationResults = ({
   ruleImplementation,
-  customColumns,
+  ruleResultsColumns,
   isAdmin,
 }) => {
   const { formatMessage, locale } = useIntl();
 
   if (_.isEmpty(ruleImplementation)) return null;
 
-  const ruleResults = ruleImplementation.results;
-  const optionalColumns = getOptionalColumnsWithData(ruleResults);
+  const implementationVersions = _.propOr([], "versions")(ruleImplementation);
+  const currentImplementationVersion = _.flow(
+    _.filter((version) => version.id === ruleImplementation.id),
+    _.first
+  )(implementationVersions);
+
+  const commonProps = {
+    ruleImplementation,
+    isAdmin,
+    ruleResultsColumns,
+    formatMessage,
+  };
 
   return (
     <>
@@ -61,77 +75,126 @@ export const RuleImplementationResults = ({
           </p>
         </Message>
       ) : null}
-      {_.isEmpty(ruleResults) ? (
-        <Message
-          style={{ marginTop: "14px" }}
-          header={formatMessage({
-            id: "rule.ruleImplementation.results.empty",
-          })}
-        />
-      ) : (
-        <Table className="implementation-results small">
-          <Table.Header>
-            <Table.Row>
-              <Table.HeaderCell
-                content={formatMessage({ id: "ruleResult.props.date" })}
-              />
-              <Table.HeaderCell
-                content={formatMessage({ id: "ruleResult.props.quality" })}
-              />
-              {_.includes("records")(optionalColumns) ? (
-                <Table.HeaderCell
-                  content={formatMessage({ id: "ruleResult.props.records" })}
-                />
-              ) : null}
-              {_.includes("errors")(optionalColumns) ? (
-                <Table.HeaderCell
-                  content={formatMessage({ id: "ruleResult.props.errors" })}
-                />
-              ) : null}
-              {customColumns.map((column, index) => (
-                <Table.HeaderCell
-                  key={index}
-                  content={formatMessage({
-                    id: `ruleResult.props.${column.name}`,
-                    defaultMessage: column.name,
-                  })}
-                />
-              ))}
-              {<Table.HeaderCell />}
-              {isAdmin ? <Table.HeaderCell /> : null}
-            </Table.Row>
-          </Table.Header>
-          <Table.Body>
-            {ruleResults.map((result, i) => (
-              <RuleResultRow
-                key={i}
-                optionalColumns={optionalColumns}
-                ruleResult={result}
-                customColumns={customColumns}
-                isAdmin={isAdmin}
-                ruleImplementation={ruleImplementation}
-              />
-            ))}
-          </Table.Body>
-        </Table>
-      )}
+      {resultsTable({
+        commonProps,
+        implementationVersions,
+        currentImplementationVersion,
+      })}
     </>
   );
 };
 
+export const resultsTable = ({
+  commonProps,
+  implementationVersions,
+  currentImplementationVersion,
+}) => {
+  const { isAdmin, ruleResultsColumns, formatMessage } = commonProps;
+
+  const ruleResults = _.flow(
+    _.map((iv) => _.pathOr([], "results")(iv)),
+    _.flatten
+  )(implementationVersions);
+  const optionalColumns = getOptionalColumnsWithData(ruleResults);
+  const customColumns = getCustomColumnsWithData(
+    ruleResults,
+    ruleResultsColumns
+  );
+
+  return _.isEmpty(ruleResults) ? (
+    <Message
+      style={{ marginTop: "14px" }}
+      header={formatMessage({
+        id: "rule.ruleImplementation.results.empty",
+      })}
+    />
+  ) : (
+    <Table className="implementation-results small">
+      <Table.Header>
+        <Table.Row>
+          <Table.HeaderCell
+            content={formatMessage({ id: "ruleResult.props.date" })}
+          />
+          <Table.HeaderCell
+            content={formatMessage({ id: "ruleResult.props.quality" })}
+          />
+          {_.includes("records")(optionalColumns) ? (
+            <Table.HeaderCell
+              content={formatMessage({ id: "ruleResult.props.records" })}
+            />
+          ) : null}
+          {_.includes("errors")(optionalColumns) ? (
+            <Table.HeaderCell
+              content={formatMessage({ id: "ruleResult.props.errors" })}
+            />
+          ) : null}
+          {customColumns.map((column, index) => (
+            <Table.HeaderCell
+              key={index}
+              content={formatMessage({
+                id: `ruleResult.props.${column.name}`,
+                defaultMessage: column.name,
+              })}
+            />
+          ))}
+          {<Table.HeaderCell />}
+          {isAdmin ? <Table.HeaderCell /> : null}
+        </Table.Row>
+      </Table.Header>
+      <Table.Body>
+        {implementationVersions.map((version, i) =>
+          _.pathOr(
+            [],
+            "results"
+          )(version).map((result, j) => (
+            <RuleResultRow
+              key={"version" + i + "_result" + j}
+              optionalColumns={optionalColumns}
+              ruleResult={result}
+              customColumns={customColumns}
+              isAdmin={isAdmin}
+              ruleImplementation={version}
+              active={currentImplementationVersion.id == version.id}
+              tagLabel={
+                j === 0
+                  ? `${formatMessage({
+                      id: "ruleImplementations.props.version",
+                    })}: ${version.version}`
+                  : null
+              }
+            />
+          ))
+        )}
+      </Table.Body>
+    </Table>
+  );
+};
+
 RuleImplementationResults.propTypes = {
   ruleImplementation: PropTypes.object,
-  customColumns: PropTypes.array,
   isAdmin: PropTypes.bool,
+  ruleResultsColumns: PropTypes.array,
 };
 
-const mapStateToProps = (state) => ({
-  ruleImplementation: state.ruleImplementation,
-  customColumns: getCustomColumnsWithData(
-    state.ruleImplementation?.results,
-    getRuleResultsColumns(state)
-  ),
-  isAdmin: state.authentication.role === "admin",
-});
+const mapStateToProps = (state) => ({ state: state });
+
+export const RuleImplementationResultsLoader = (props) => {
+  const { state } = props;
+  const { implementation_id: id } = useParams();
+  const { loading, error, data } = useQuery(IMPLEMENTATION_RESULTS, {
+    variables: { id },
+  });
+  if (error) return null;
+  if (loading) return <Loading />;
+  const ruleImplementation = data?.implementation;
+  const componentProperties = {
+    ruleImplementation,
+    ruleResultsColumns: getRuleResultsColumns(state),
+    isAdmin: state.authentication.role === "admin",
+  };
+  return <RuleImplementationResults {...componentProperties} />;
+};
 
-export default connect(mapStateToProps)(RuleImplementationResults);
+export default connect(mapStateToProps, { RuleImplementationResults })(
+  RuleImplementationResultsLoader
+);

package/src/components/RuleResult.js

@@ -2,19 +2,11 @@ import _ from "lodash/fp";
 import React from "react";
 import PropTypes from "prop-types";
 import { connect } from "react-redux";
-import { useParams } from "react-router-dom";
 import { Header, Icon } from "semantic-ui-react";
 import { FormattedMessage } from "react-intl";
 import RuleImplementationResultTabs from "./RuleImplementationResultTabs";
 
-export const RuleResult = ({ ruleImplementation, ruleResultId, children }) => {
-  const { rule_result_id: paramsId } = useParams();
-  const resultId = _.defaultTo(_.toNumber(paramsId))(ruleResultId);
-
-  const ruleResult = _.find(_.propEq("id", resultId))(
-    ruleImplementation.results
-  );
-
+export const RuleResult = ({ ruleResult, children }) => {
   const renderRuleResult = () => {
     return (
       <>
@@ -34,20 +26,14 @@ export const RuleResult = ({ ruleImplementation, ruleResultId, children }) => {
 };
 
 RuleResult.propTypes = {
-  ruleImplementation: PropTypes.object,
-  ruleResultId: PropTypes.number,
+  ruleResult: PropTypes.object,
   children: PropTypes.oneOfType([
     PropTypes.node,
     PropTypes.arrayOf(PropTypes.node),
   ]),
 };
 
-const mapStateToProps = ({
-  ruleImplementation,
-  remediationLoading,
-  templatesLoading,
-}) => ({
-  ruleImplementation,
+const mapStateToProps = ({ remediationLoading, templatesLoading }) => ({
   remediationLoading,
   templatesLoading,
 });

package/src/components/RuleResultDetails.js

@@ -3,7 +3,6 @@ import React from "react";
 import PropTypes from "prop-types";
 import { useIntl } from "react-intl";
 import { connect } from "react-redux";
-import { useParams } from "react-router-dom";
 import { Table, Icon } from "semantic-ui-react";
 import { DateTime } from "@truedat/core/components";
 import { selectColor } from "../functions/selectors";
@@ -82,15 +81,8 @@ const DetailRow = ({ details }) => {
 
 DetailRow.propTypes = { details: PropTypes.object };
 
-export const RuleResultDetails = ({ ruleImplementation, ruleResultId }) => {
+export const RuleResultDetails = ({ ruleImplementation, ruleResult }) => {
   const { formatMessage } = useIntl();
-  const { rule_result_id: paramsId } = useParams();
-
-  const resultId = _.defaultTo(_.toNumber(paramsId))(ruleResultId);
-
-  const ruleResult = _.find(_.propEq("id", resultId))(
-    ruleImplementation.results
-  );
 
   return _.isEmpty(ruleResult) ? null : (
     <>
@@ -136,6 +128,7 @@ export const RuleResultDetails = ({ ruleImplementation, ruleResultId }) => {
 RuleResultDetails.propTypes = {
   ruleImplementation: PropTypes.object,
   ruleResultId: PropTypes.number,
+  ruleResult: PropTypes.object,
 };
 
 const mapStateToProps = ({ ruleImplementation }) => ({ ruleImplementation });

package/src/components/RuleResultRemediations.js

@@ -1,38 +1,22 @@
 import _ from "lodash/fp";
 import React from "react";
 import PropTypes from "prop-types";
-import { connect } from "react-redux";
-import { useParams } from "react-router-dom";
 import RemediationPlan from "./RemediationPlan";
 import "../styles/executionDetails.less";
 
-export const RuleResultRemediations = ({
-  ruleImplementation,
-  ruleResultId,
-}) => {
-  const { rule_result_id: paramsId } = useParams();
-
-  const resultId = _.defaultTo(_.toNumber(paramsId))(ruleResultId);
-
-  const ruleResult = _.find(_.propEq("id", resultId))(
-    ruleImplementation.results
-  );
-
+export const RuleResultRemediations = ({ ruleResult }) => {
+  const resultId = ruleResult.id;
   return _.isEmpty(ruleResult) ? null : (
-    <>
-      <RemediationPlan
-        className="execution-details-remediation"
-        latestResultId={resultId}
-      />
-    </>
+    <RemediationPlan
+      className="execution-details-remediation"
+      latestResultId={resultId}
+    />
   );
 };
 
 RuleResultRemediations.propTypes = {
   ruleImplementation: PropTypes.object,
-  ruleResultId: PropTypes.number,
+  ruleResult: PropTypes.object,
 };
 
-const mapStateToProps = ({ ruleImplementation }) => ({ ruleImplementation });
-
-export default connect(mapStateToProps)(RuleResultRemediations);
+export default RuleResultRemediations;