@truedat/dq 4.43.6 → 4.44.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [4.44.2] 2022-05-11
+
+### Fixed
+
+- [TD-4089] Segments tab was not displaying segments
+
+## [4.44.1] 2022-05-11
+
+### Added
+
+- [TD-4089] Support for Implementations without Rules
+
 ## [4.43.5] 2022-05-05
 
 # Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.43.6",
+  "version": "4.44.2",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -31,7 +31,7 @@
     "@babel/plugin-transform-modules-commonjs": "^7.15.0",
     "@babel/preset-env": "^7.15.0",
     "@babel/preset-react": "^7.14.5",
-    "@truedat/test": "4.43.6",
+    "@truedat/test": "4.44.2",
     "babel-jest": "^27.0.6",
     "babel-plugin-dynamic-import-node": "^2.3.3",
     "babel-plugin-lodash": "^3.3.4",
@@ -82,8 +82,8 @@
   },
   "dependencies": {
     "@apollo/client": "^3.4.10",
-    "@truedat/core": "4.43.6",
-    "@truedat/df": "4.43.6",
+    "@truedat/core": "4.44.2",
+    "@truedat/df": "4.44.2",
     "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": "848143d79486499dd9deadea6a545929b5cdb39c"
+  "gitHead": "ca0c5fffcba96736f7a2054f3c37789da8c30a9e"
 }

package/src/components/ImplementationCrumbs.js

@@ -0,0 +1,91 @@
+import _ from "lodash/fp";
+import React from "react";
+import PropTypes from "prop-types";
+import { Breadcrumb } from "semantic-ui-react";
+import { connect } from "react-redux";
+import { Link, useParams } from "react-router-dom";
+import { FormattedMessage } from "react-intl";
+import { RULES, IMPLEMENTATIONS, linkTo } from "@truedat/core/routes";
+import { DateTime } from "@truedat/core/components";
+
+export const ImplementationCrumbs = ({ ruleImplementation }) => {
+  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);
+
+  return (
+    <Breadcrumb>
+      {rule ? (
+        <>
+          <Breadcrumb.Section as={Link} to={RULES} active={false}>
+            <FormattedMessage id="rules.crumbs.top" />
+          </Breadcrumb.Section>
+          {rule.name && (
+            <>
+              <Breadcrumb.Divider icon="right angle" />
+              {ruleImplementation.id ? (
+                <Breadcrumb.Section
+                  as={Link}
+                  to={linkTo.RULE({ id: ruleImplementation.rule_id })}
+                  active={_.isEmpty(ruleImplementation)}
+                >
+                  {rule.name}
+                </Breadcrumb.Section>
+              ) : (
+                <Breadcrumb.Section active>{rule.name}</Breadcrumb.Section>
+              )}
+            </>
+          )}
+        </>
+      ) : (
+        <Breadcrumb.Section as={Link} to={IMPLEMENTATIONS} active={false}>
+          <FormattedMessage id="implementations.crumbs.top" />
+        </Breadcrumb.Section>
+      )}
+
+      {ruleImplementation.id && (
+        <>
+          <Breadcrumb.Divider icon="right angle" />
+          {rule_result_id ? (
+            <Breadcrumb.Section
+              as={Link}
+              to={linkTo.IMPLEMENTATION({
+                implementation_id: ruleImplementation.id,
+              })}
+              active={_.isEmpty(ruleImplementation)}
+            >
+              {ruleImplementation.implementation_key}
+            </Breadcrumb.Section>
+          ) : (
+            <Breadcrumb.Section active>
+              {ruleImplementation.implementation_key}
+            </Breadcrumb.Section>
+          )}
+        </>
+      )}
+      {rule_result_id && (
+        <>
+          <Breadcrumb.Divider icon="right angle" />
+          <Breadcrumb.Section active>
+            {<DateTime value={ruleResultDate} />}
+          </Breadcrumb.Section>
+        </>
+      )}
+    </Breadcrumb>
+  );
+};
+
+ImplementationCrumbs.propTypes = {
+  ruleImplementation: PropTypes.object,
+};
+
+const mapStateToProps = ({ rule, ruleImplementation }) => ({
+  rule,
+  ruleImplementation,
+});
+export default connect(mapStateToProps)(ImplementationCrumbs);

package/src/components/ImplementationResultBar.js

@@ -52,8 +52,7 @@ export default function ImplementationResultBar({ implementation }) {
       <Link
         as="div"
         className="rule-summary pointer"
-        to={linkTo.RULE_IMPLEMENTATION_RESULTS({
-          id: implementation.rule_id,
+        to={linkTo.IMPLEMENTATION_RESULTS({
           implementation_id: implementation.id,
         })}
       >

package/src/components/ImplementationStructures.js

@@ -74,20 +74,18 @@ export const ImplementationStructures = ({ implementation, canCreateLink }) => {
     />
   ));
 
-  const id = _.prop("rule_id")(implementation);
   const implementation_id = _.prop("id")(implementation);
 
   return (
     <Segment attached="bottom">
       <Grid>
-        {id && canCreateLink && (
+        {implementation_id && canCreateLink && (
           <Grid.Column width={16}>
             <Button
               floated="right"
               primary
               as={Link}
               to={linkTo.IMPLEMENTATION_STRUCTURES_NEW({
-                id,
                 implementation_id,
               })}
               content={<FormattedMessage id="links.actions.create" />}

package/src/components/Implementations.js

@@ -78,9 +78,10 @@ export const Implementations = ({
   deletedRender,
   setRuleImplementationStatus,
   manageRuleImplementationAction,
+  rule,
 }) => {
   const handleStatusChange = (id, mode) =>
-    setRuleImplementationStatus({ id, ...mode });
+    setRuleImplementationStatus({ id, ruleId: rule?.id, ...mode });
   const additionalColumns = manageRuleImplementationAction
     ? [<Table.HeaderCell key={"status"} width={1} />]
     : [];
@@ -107,13 +108,19 @@ Implementations.propTypes = {
   deletedRender: PropTypes.bool,
   setRuleImplementationStatus: PropTypes.func,
   manageRuleImplementationAction: PropTypes.bool,
+  rule: PropTypes.object,
 };
 
-const mapStateToProps = ({ ruleImplementations, userRulePermissions }) => ({
+const mapStateToProps = ({
+  ruleImplementations,
+  userRulePermissions,
+  rule,
+}) => ({
   ruleImplementations,
   manageRuleImplementationAction: _.prop("manage_quality_rule_implementations")(
     userRulePermissions
   ),
+  rule,
 });
 
 export default connect(mapStateToProps, { setRuleImplementationStatus })(

package/src/components/ImplementationsRoutes.js

@@ -1,30 +1,399 @@
+import _ from "lodash/fp";
 import React from "react";
-import { Route } from "react-router-dom";
-import { IMPLEMENTATIONS } from "@truedat/core/routes";
+import PropTypes from "prop-types";
+import { Route, Switch, useRouteMatch, useParams } from "react-router-dom";
+import { connect } from "react-redux";
+import { Segment } from "semantic-ui-react";
+import { Unauthorized } from "@truedat/core/components";
+import { useAuthorized } from "@truedat/core/hooks";
+import {
+  IMPLEMENTATION_CLONE,
+  IMPLEMENTATION_CONCEPT_LINKS_NEW,
+  IMPLEMENTATION_CONCEPT_LINKS,
+  IMPLEMENTATION_EDIT,
+  IMPLEMENTATION_EVENTS,
+  IMPLEMENTATION_MOVE,
+  IMPLEMENTATION_NEW,
+  IMPLEMENTATION_NEW_RAW,
+  IMPLEMENTATION_RESULT_DETAILS,
+  IMPLEMENTATION_RESULTS_DETAILS,
+  IMPLEMENTATION_RESULTS,
+  IMPLEMENTATION_STRUCTURES_NEW,
+  IMPLEMENTATION_STRUCTURES,
+  IMPLEMENTATION,
+  IMPLEMENTATIONS,
+} from "@truedat/core/routes";
+import {
+  getImplementationStructures,
+  getImplementationStructuresLoaded,
+} from "../selectors";
+import ImplementationCrumbs from "./ImplementationCrumbs";
 import ImplementationFiltersLoader from "./ImplementationFiltersLoader";
 import RuleImplementations from "./RuleImplementations";
 import RuleImplementationsLoader from "./RuleImplementationsLoader";
 
+import ImplementationStructures from "./ImplementationStructures";
+import ImplementationStructuresNew from "./ImplementationStructuresNew";
+import MoveImplementation from "./MoveImplementation";
+import NewRuleImplementation from "./NewRuleImplementation";
+import RuleImplementation from "./RuleImplementation";
+import RuleImplementationEvents from "./RuleImplementationEvents";
+import RuleImplementationLoader from "./RuleImplementationLoader";
+import RuleImplementationProperties from "./RuleImplementationProperties";
+import RuleImplementationResults from "./RuleImplementationResults";
+import RuleResultDetails from "./RuleResultDetails";
+import RuleResultsRoutes from "./RuleResultsRoutes";
+import RuleResultRemediationLoader from "./RuleResultRemediationLoader";
+
 const TemplatesLoader = React.lazy(() =>
   import("@truedat/df/templates/components/TemplatesLoader")
 );
 const UserSearchFiltersLoader = React.lazy(() =>
   import("@truedat/dd/components/UserSearchFiltersLoader")
 );
-
-const ImplementationsRoutes = () => (
-  <Route
-    path={IMPLEMENTATIONS}
-    render={() => (
-      <>
-        <RuleImplementationsLoader />
-        <ImplementationFiltersLoader />
-        <TemplatesLoader scope="qe" />
-        <UserSearchFiltersLoader scope="rule_implementation" />
-        <RuleImplementations exact />
-      </>
-    )}
-  />
+const DomainsLoader = React.lazy(() =>
+  import("@truedat/bg/taxonomy/components/DomainsLoader")
+);
+const EventsLoader = React.lazy(() =>
+  import("@truedat/audit/components/EventsLoader")
+);
+const ImplementationStructuresLoader = React.lazy(() =>
+  import("@truedat/dd/components/ImplementationStructuresLoader")
+);
+const ImplementationLinks = React.lazy(() =>
+  import("@truedat/lm/components/ImplementationLinks")
 );
+const ImplementationRelationForm = React.lazy(() =>
+  import("@truedat/lm/components/ImplementationRelationForm")
+);
+
+const ImplementationEventsLoader = () => {
+  const match = useRouteMatch();
+  const id = _.path("params.implementation_id")(match);
+  return <EventsLoader resource_id={id} resource_type="implementation" />;
+};
+
+const ImplementationTemplatesLoader = () => <TemplatesLoader scope="ri" />;
+
+const ImplementationsRoutes = ({
+  structuresAliasesLoading,
+  systemsLoading,
+  ruleImplementationLoaded,
+  ruleImplementation,
+  implementationStructures,
+  implementationStructuresLoaded,
+}) => {
+  const latest = _.head(ruleImplementation.results);
+  const authorized = useAuthorized();
+  const { rule_result_id: ruleResultId } = useParams();
+  return (
+    <Switch>
+      <Route
+        exact
+        path={IMPLEMENTATION_NEW}
+        render={() => (
+          <>
+            <DomainsLoader
+              actions={[
+                "manage_ruleless_implementations",
+                "manage_quality_rule_implementations",
+              ]}
+              filter="all"
+            />
+            <TemplatesLoader scope="ri" />
+            {!structuresAliasesLoading && !systemsLoading && (
+              <NewRuleImplementation edition={false} />
+            )}
+          </>
+        )}
+      />
+      <Route
+        exact
+        path={IMPLEMENTATION_NEW_RAW}
+        render={() => (
+          <>
+            <DomainsLoader
+              actions={[
+                "manage_ruleless_implementations",
+                "manage_raw_quality_rule_implementations",
+              ]}
+              filter="all"
+            />
+            <TemplatesLoader scope="ri" />
+            {!structuresAliasesLoading && !systemsLoading && (
+              <NewRuleImplementation edition={false} implementationType="raw" />
+            )}
+          </>
+        )}
+      />
+      <Route
+        path={IMPLEMENTATION}
+        render={() => (
+          <>
+            <RuleImplementationLoader />
+
+            <Route
+              exact
+              path={IMPLEMENTATION}
+              render={() => (
+                <>
+                  <ImplementationCrumbs />
+                  <Segment>
+                    <ImplementationTemplatesLoader />
+                    {ruleImplementationLoaded && (
+                      <RuleImplementation>
+                        <RuleImplementationProperties />
+                      </RuleImplementation>
+                    )}
+                  </Segment>
+                </>
+              )}
+            />
+
+            <Route
+              exact
+              path={IMPLEMENTATION_EVENTS}
+              render={() => (
+                <>
+                  <ImplementationCrumbs />
+                  <Segment>
+                    <ImplementationEventsLoader />
+                    {ruleImplementationLoaded && (
+                      <RuleImplementation>
+                        <RuleImplementationEvents />
+                      </RuleImplementation>
+                    )}
+                  </Segment>
+                </>
+              )}
+            />
+
+            <Route
+              exact
+              path={IMPLEMENTATION_CLONE}
+              render={() => (
+                <>
+                  {!ruleImplementation?.rule_id ? (
+                    <DomainsLoader
+                      actions={[
+                        "manage_ruleless_implementations",
+                        ruleImplementation?.implementation_type === "raw"
+                          ? "manage_raw_quality_rule_implementations"
+                          : "manage_quality_rule_implementations",
+                      ]}
+                      filter="all"
+                    />
+                  ) : null}
+
+                  <ImplementationTemplatesLoader />
+                  {ruleImplementationLoaded && (
+                    <ImplementationStructuresLoader
+                      structureIds={implementationStructures}
+                    />
+                  )}
+                  {!structuresAliasesLoading &&
+                    ruleImplementationLoaded &&
+                    implementationStructuresLoaded && (
+                      <NewRuleImplementation edition={true} clone={true} />
+                    )}
+                </>
+              )}
+            />
+            <Route
+              exact
+              path={IMPLEMENTATION_EDIT}
+              render={() => (
+                <>
+                  {!ruleImplementation?.rule_id ? (
+                    <DomainsLoader
+                      actions={[
+                        "manage_ruleless_implementations",
+                        ruleImplementation?.implementation_type === "raw"
+                          ? "manage_raw_quality_rule_implementations"
+                          : "manage_quality_rule_implementations",
+                      ]}
+                      filter="all"
+                    />
+                  ) : null}
+
+                  <ImplementationTemplatesLoader />
+                  {ruleImplementationLoaded && (
+                    <ImplementationStructuresLoader
+                      structureIds={implementationStructures}
+                    />
+                  )}
+                  {!structuresAliasesLoading &&
+                    ruleImplementationLoaded &&
+                    implementationStructuresLoaded && (
+                      <NewRuleImplementation edition />
+                    )}
+                </>
+              )}
+            />
+
+            <Route
+              exact
+              path={IMPLEMENTATION_MOVE}
+              render={() => (
+                <>
+                  <ImplementationCrumbs />
+                  <Segment>
+                    {ruleImplementationLoaded ? (
+                      <RuleImplementation>
+                        {authorized ? <MoveImplementation /> : <Unauthorized />}
+                      </RuleImplementation>
+                    ) : null}
+                  </Segment>
+                </>
+              )}
+            />
+            <Route
+              exact
+              path={IMPLEMENTATION_CONCEPT_LINKS}
+              render={() => (
+                <>
+                  <ImplementationCrumbs />
+                  <Segment>
+                    {ruleImplementationLoaded && (
+                      <RuleImplementation>
+                        <ImplementationLinks />
+                      </RuleImplementation>
+                    )}
+                  </Segment>
+                </>
+              )}
+            />
+            <Route
+              exact
+              path={IMPLEMENTATION_CONCEPT_LINKS_NEW}
+              render={() => (
+                <>
+                  <ImplementationCrumbs />
+                  <Segment>
+                    {ruleImplementationLoaded && (
+                      <RuleImplementation>
+                        <ImplementationRelationForm />
+                      </RuleImplementation>
+                    )}
+                  </Segment>
+                </>
+              )}
+            />
+            <Route
+              exact
+              path={IMPLEMENTATION_STRUCTURES}
+              render={() => (
+                <>
+                  <ImplementationCrumbs />
+                  <Segment>
+                    {ruleImplementationLoaded && (
+                      <RuleImplementation>
+                        <ImplementationStructures />
+                      </RuleImplementation>
+                    )}
+                  </Segment>
+                </>
+              )}
+            />
+            <Route
+              exact
+              path={IMPLEMENTATION_STRUCTURES_NEW}
+              render={() => (
+                <>
+                  <ImplementationCrumbs />
+                  <Segment>
+                    {ruleImplementationLoaded && (
+                      <RuleImplementation>
+                        <ImplementationStructuresNew />
+                      </RuleImplementation>
+                    )}
+                  </Segment>
+                </>
+              )}
+            />
+            <Route
+              exact
+              path={IMPLEMENTATION_RESULTS}
+              render={() => (
+                <>
+                  <ImplementationCrumbs />
+                  <Segment>
+                    {ruleImplementationLoaded && (
+                      <RuleImplementation>
+                        <RuleImplementationResults ruleResult={latest} />
+                      </RuleImplementation>
+                    )}
+                  </Segment>
+                </>
+              )}
+            />
+
+            <Route
+              exact
+              path={IMPLEMENTATION_RESULTS_DETAILS}
+              render={() => (
+                <>
+                  <ImplementationCrumbs />
+                  <Segment>
+                    {ruleImplementationLoaded && (
+                      <RuleImplementation>
+                        <RuleResultDetails ruleResultId={latest.id} />
+                      </RuleImplementation>
+                    )}
+                  </Segment>
+                </>
+              )}
+            />
+            <Route
+              path={IMPLEMENTATION_RESULT_DETAILS}
+              render={() => (
+                <>
+                  <RuleResultRemediationLoader
+                    propRuleResultId={ruleResultId}
+                  />
+                  <TemplatesLoader scope="remediation" />
+                  <RuleResultsRoutes />
+                </>
+              )}
+            />
+          </>
+        )}
+      />
+      <Route
+        path={IMPLEMENTATIONS}
+        render={() => (
+          <>
+            <RuleImplementationsLoader />
+            <ImplementationFiltersLoader />
+            <TemplatesLoader scope="qe" />
+            <UserSearchFiltersLoader scope="rule_implementation" />
+            <RuleImplementations exact />
+          </>
+        )}
+      />
+    </Switch>
+  );
+};
+
+ImplementationsRoutes.propTypes = {
+  structuresAliasesLoading: PropTypes.bool,
+  systemsLoading: PropTypes.bool,
+  ruleImplementationLoaded: PropTypes.bool,
+  ruleImplementation: PropTypes.object,
+  implementationStructures: PropTypes.array,
+  implementationStructuresLoaded: PropTypes.bool,
+};
+
+export const mapStateToProps = (state) => ({
+  ..._.pick([
+    "structuresAliasesLoading",
+    "systemsLoading",
+    "ruleImplementation",
+  ])(state),
+  ruleImplementationLoaded:
+    !state.ruleImplementationLoading && !_.isEmpty(state.ruleImplementation),
+  implementationStructures: getImplementationStructures(state),
+  implementationStructuresLoaded: getImplementationStructuresLoaded(state),
+});
 
-export default ImplementationsRoutes;
+export default connect(mapStateToProps)(ImplementationsRoutes);