@truedat/dq 4.45.4 → 4.45.7

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [4.45.7] 2022-06-07
+
+### Fixed
+
+- [TD-4915] RuleImplementations table are not working in structure view
+
+## [4.45.6] 2022-06-06
+
+### Added
+
+- [TD-4655] Add errored status for quality execution subscriptions
+- [TD-4540] Support for rule implementation workflow
+
 ## [4.45.2] 2022-05-31
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.45.4",
+  "version": "4.45.7",
   "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.45.1",
+    "@truedat/test": "4.45.7",
     "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.45.1",
-    "@truedat/df": "4.45.4",
+    "@truedat/core": "4.45.7",
+    "@truedat/df": "4.45.7",
     "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": "40ec430c50a2da5eca991e9b946e8e47ffe1e477"
+  "gitHead": "d3c6c144cc850972e0e602967e23259a1e176a2c"
 }

package/src/api/mutations.js

@@ -0,0 +1,25 @@
+import { gql } from "@apollo/client";
+
+export const SUBMIT_IMPLEMENTATION = gql`
+  mutation SubmitImplementation($id: ID!) {
+    submitImplementation(id: $id) {
+      id
+    }
+  }
+`;
+
+export const REJECT_IMPLEMENTATION = gql`
+  mutation rejectImplementation($id: ID!) {
+    rejectImplementation(id: $id) {
+      id
+    }
+  }
+`;
+
+export const PUBLISH_IMPLEMENTATION = gql`
+  mutation publishImplementation($id: ID!) {
+    publishImplementation(id: $id) {
+      id
+    }
+  }
+`;

package/src/components/ImplementationActions.js

@@ -0,0 +1,147 @@
+import _ from "lodash/fp";
+import React from "react";
+import PropTypes from "prop-types";
+import { Link } from "react-router-dom";
+import { useIntl } from "react-intl";
+import { connect } from "react-redux";
+import { Button } from "semantic-ui-react";
+import { GroupActions, OptionModal } from "@truedat/core/components";
+import { linkTo, IMPLEMENTATIONS } from "@truedat/core/routes";
+import {
+  createExecutionGroup,
+  submitImplementation,
+  publishImplementation,
+  rejectImplementation,
+  deleteImplementation,
+} from "../routines";
+import ExecutionPopup from "./ExecutionPopup";
+
+export const implementationActions = ({
+  id,
+  deleteImplementation,
+  formatMessage,
+}) => [
+  {
+    key: "clone",
+    icon: "copy outline",
+    text: formatMessage({ id: "ruleImplementation.actions.clone" }),
+    value: "clone",
+    as: Link,
+    to: linkTo.IMPLEMENTATION_CLONE({ implementation_id: id }),
+  },
+  {
+    key: "move",
+    icon: "share square",
+    text: formatMessage({ id: "ruleImplementation.actions.move" }),
+    value: "move",
+    as: Link,
+    to: linkTo.IMPLEMENTATION_MOVE({ implementation_id: id }),
+  },
+  {
+    key: "delete",
+    value: "delete",
+    as: OptionModal,
+    headerMessage: "ruleImplementation.actions.delete.confirmation.header",
+    contentMessage: "ruleImplementation.actions.delete.confirmation.content",
+    iconName: "trash alternate outline",
+    iconColor: "red",
+    option: "ruleImplementation.actions.delete",
+    onConfirm: () => deleteImplementation({ id, redirectUrl: IMPLEMENTATIONS }),
+  },
+];
+
+export const ImplementationActions = ({
+  actions,
+  createExecutionGroup,
+  deleteImplementation,
+  publishImplementation,
+  rejectImplementation,
+  ruleImplementation,
+  submitImplementation,
+}) => {
+  const { formatMessage } = useIntl();
+  const id = ruleImplementation?.id;
+  const handleExecute = (df_content) => {
+    const query = { filters: { id: [ruleImplementation?.id] } };
+    createExecutionGroup({ ...query, df_content });
+  };
+  const secondaryActions = implementationActions({
+    id,
+    deleteImplementation,
+    formatMessage,
+  });
+  return (
+    <>
+      {actions?.edit ? (
+        <Button
+          primary
+          content={formatMessage({ id: "actions.edit" })}
+          as={Link}
+          to={linkTo.IMPLEMENTATION_EDIT({ implementation_id: id })}
+        />
+      ) : null}
+      {actions?.publish ? (
+        <Button
+          primary
+          content={formatMessage({ id: "actions.publish" })}
+          onClick={() =>
+            publishImplementation({
+              id,
+              redirectUrl: linkTo.IMPLEMENTATION({ implementation_id: id }),
+            })
+          }
+        />
+      ) : null}
+      {actions?.reject ? (
+        <Button
+          secondary
+          content={formatMessage({ id: "actions.reject" })}
+          onClick={() =>
+            rejectImplementation({
+              id,
+              redirectUrl: linkTo.IMPLEMENTATION({ implementation_id: id }),
+            })
+          }
+        />
+      ) : null}
+      {actions?.submit ? (
+        <Button
+          content={formatMessage({ id: "actions.submit" })}
+          onClick={() =>
+            submitImplementation({
+              id,
+              redirectUrl: linkTo.IMPLEMENTATION({ implementation_id: id }),
+            })
+          }
+        />
+      ) : null}
+      {actions?.execute ? <ExecutionPopup onSubmit={handleExecute} /> : null}
+      <GroupActions availableActions={secondaryActions} />
+    </>
+  );
+};
+
+ImplementationActions.propTypes = {
+  actions: PropTypes.object,
+  deleteImplementation: PropTypes.func,
+  publishImplementation: PropTypes.func,
+  rejectImplementation: PropTypes.func,
+  ruleImplementation: PropTypes.object,
+  submitImplementation: PropTypes.func,
+};
+
+export const mapStateToProps = ({
+  implementationActions,
+  ruleImplementation,
+}) => ({
+  actions: implementationActions,
+  ruleImplementation,
+});
+
+export default connect(mapStateToProps, {
+  createExecutionGroup,
+  deleteImplementation,
+  publishImplementation,
+  rejectImplementation,
+  submitImplementation,
+})(ImplementationActions);

package/src/components/ImplementationFiltersLoader.js

@@ -16,13 +16,14 @@ const mapDispatchToProps = (dispatch) =>
     dispatch
   );
 
-const makeMapStateToProps = () => {
+export const makeMapStateToProps = () => {
   const activeFiltersSelector = makeActiveFiltersSelector(
     "ruleImplementationActiveFilters"
   );
   const mapStateToProps = (state, props) => ({
     selectedFilter: state.ruleImplementationSelectedFilter,
     filters: activeFiltersSelector(state, props),
+    defaultFilters: props?.defaultFilters || {},
   });
   return mapStateToProps;
 };

package/src/components/{RuleImplementations.js → ImplementationSearchResults.js}

@@ -4,6 +4,8 @@ import PropTypes from "prop-types";
 import { connect } from "react-redux";
 import { Dimmer, Header, Icon, Loader, Segment } from "semantic-ui-react";
 import { FormattedMessage } from "react-intl";
+import { useActiveRoute } from "@truedat/core/hooks";
+import { IMPLEMENTATIONS_PENDING } from "@truedat/core/routes";
 import { getExecutionQuery } from "../selectors";
 import RuleImplementationsActions from "./RuleImplementationsActions";
 import RuleImplementationsLabelResults from "./RuleImplementationsLabelResults";
@@ -12,7 +14,7 @@ import RuleImplementationsSearch from "./RuleImplementationsSearch";
 import RuleImplementationsTable from "./RuleImplementationsTable";
 import RuleImplementationSelectedFilters from "./RuleImplementationSelectedFilters";
 
-const usePrevious = value => {
+const usePrevious = (value) => {
   const ref = useRef();
   useEffect(() => {
     ref.current = value;
@@ -20,11 +22,32 @@ const usePrevious = value => {
   return ref.current;
 };
 
-export const RuleImplementations = ({
+export const ImplementationSearchResultsHeader = () => {
+  const pending = useActiveRoute(IMPLEMENTATIONS_PENDING);
+  const header = pending
+    ? "implementations.header.manage"
+    : "implementations.header";
+  const subheader = pending
+    ? "implementations.subheader.manage"
+    : "implementations.subheader";
+  return (
+    <Header as="h2">
+      <Icon circular name="tags" />
+      <Header.Content>
+        <FormattedMessage id={header} />
+        <Header.Subheader>
+          <FormattedMessage id={subheader} />
+        </Header.Subheader>
+      </Header.Content>
+    </Header>
+  );
+};
+
+export const ImplementationSearchResults = ({
   implementationQuery,
   role,
   loading,
-  ruleImplementations
+  ruleImplementations,
 }) => {
   const [executeImplementationsOn, setMode] = useState(
     _.matches({ filters: { executable: [true] } })(implementationQuery)
@@ -41,7 +64,7 @@ export const RuleImplementations = ({
     const ids = _.map(_.prop("id"))(ruleImplementations);
     return (
       _.negate(_.isEmpty)(selectedImplementations) &&
-      _.every(id => _.includes(id)(selectedImplementations))(ids)
+      _.every((id) => _.includes(id)(selectedImplementations))(ids)
     );
   };
 
@@ -56,15 +79,15 @@ export const RuleImplementations = ({
           _.flow(_.difference(selectedImplementations), _.uniq)(ids)
         );
   };
-  const checkRow = implementation => {
+  const checkRow = (implementation) => {
     const id = _.prop("id")(implementation);
-    const exists = _.some(selectedId => _.eq(id, selectedId))(
+    const exists = _.some((selectedId) => _.eq(id, selectedId))(
       selectedImplementations
     );
     exists
       ? setSelectedImplementations(
           _.flow(
-            _.remove(selectedId => _.eq(id, selectedId)),
+            _.remove((selectedId) => _.eq(id, selectedId)),
             _.uniq
           )(selectedImplementations)
         )
@@ -72,69 +95,61 @@ export const RuleImplementations = ({
           _.flow(_.concat(id), _.uniq)(selectedImplementations)
         );
   };
-  const isRowChecked = implementation => {
+  const isRowChecked = (implementation) => {
     const id = _.prop("id")(implementation);
-    return _.some(selectedId => _.eq(id, selectedId))(selectedImplementations);
+    return _.some((selectedId) => _.eq(id, selectedId))(
+      selectedImplementations
+    );
   };
 
   return (
-    <>
-      <Segment>
-        <Header as="h2">
-          <Icon circular name="tags" />
-          <Header.Content>
-            <FormattedMessage id="ruleImplementations.header" />
-            <Header.Subheader>
-              <FormattedMessage id="ruleImplementations.subheader" />
-            </Header.Subheader>
-          </Header.Content>
-        </Header>
-        <Segment attached="bottom">
-          <RuleImplementationsActions
+    <Segment>
+      <ImplementationSearchResultsHeader />
+      <Segment attached="bottom">
+        <RuleImplementationsActions
+          executeImplementationsOn={executeImplementationsOn}
+          implementationQuery={implementationQuery}
+          role={role}
+          setMode={setMode}
+          selectedImplementations={selectedImplementations}
+        />
+        <RuleImplementationsSearch />
+        <RuleImplementationSelectedFilters />
+        <Dimmer.Dimmable dimmed={loading}>
+          <Dimmer active={loading} inverted>
+            <Loader />
+          </Dimmer>
+          <RuleImplementationsLabelResults
+            executeImplementationsOn={executeImplementationsOn}
+            implementationsToExecute={_.size(selectedImplementations)}
+          />
+          <RuleImplementationsTable
+            addAll={addAll}
+            checkedAll={allChecked()}
+            checkRow={checkRow}
             executeImplementationsOn={executeImplementationsOn}
-            implementationQuery={implementationQuery}
-            role={role}
-            setMode={setMode}
+            isRowChecked={isRowChecked}
             selectedImplementations={selectedImplementations}
           />
-          <RuleImplementationsSearch />
-          <RuleImplementationSelectedFilters />
-          <Dimmer.Dimmable dimmed={loading}>
-            <Dimmer active={loading} inverted>
-              <Loader />
-            </Dimmer>
-            <RuleImplementationsLabelResults
-              executeImplementationsOn={executeImplementationsOn}
-              implementationsToExecute={_.size(selectedImplementations)}
-            />
-            <RuleImplementationsTable
-              addAll={addAll}
-              checkedAll={allChecked()}
-              checkRow={checkRow}
-              executeImplementationsOn={executeImplementationsOn}
-              isRowChecked={isRowChecked}
-              selectedImplementations={selectedImplementations}
-            />
-            <RuleImplementationsPagination />
-          </Dimmer.Dimmable>
-        </Segment>
+          <RuleImplementationsPagination />
+        </Dimmer.Dimmable>
       </Segment>
-    </>
+    </Segment>
   );
 };
 
-RuleImplementations.propTypes = {
+ImplementationSearchResults.propTypes = {
   implementationQuery: PropTypes.object,
   role: PropTypes.string,
   loading: PropTypes.bool,
-  ruleImplementations: PropTypes.array
+  ruleImplementations: PropTypes.array,
 };
 
-const mapStateToProps = state => ({
+const mapStateToProps = (state) => ({
   implementationQuery: getExecutionQuery(state),
-  role: state.authentication.role,
+  role: state.authentication?.role,
   loading: state.ruleImplementationsLoading,
-  ruleImplementations: state.ruleImplementations
+  ruleImplementations: state.ruleImplementations,
 });
 
-export default connect(mapStateToProps)(RuleImplementations);
+export default connect(mapStateToProps)(ImplementationSearchResults);

package/src/components/Implementations.js

@@ -1,128 +1,24 @@
-import _ from "lodash/fp";
 import React from "react";
 import PropTypes from "prop-types";
-import { useIntl } from "react-intl";
-import { connect } from "react-redux";
-import { Table, Icon } from "semantic-ui-react";
-import { ConfirmModal } from "@truedat/core/components";
-import { setRuleImplementationStatus } from "../routines";
-import RuleImplementationsTable from "./RuleImplementationsTable";
+import ImplementationFiltersLoader from "./ImplementationFiltersLoader";
+import ImplementationSearchResults from "./ImplementationSearchResults";
+import RuleImplementationsLoader from "./RuleImplementationsLoader";
 
-export const ActionsCell = ({
-  id,
-  deleted_at: deletedAt,
-  handleStatusChange,
-}) => {
-  const { formatMessage } = useIntl();
-  const active = _.isNil(deletedAt);
-  const deleted = !active;
-  const mode = deleted ? "delete" : "deprecate";
-  return (
-    <>
-      {deleted && (
-        <ConfirmModal
-          trigger={<Icon name="undo" />}
-          header={formatMessage({
-            id: `ruleImplementation.actions.restore.confirmation.header`,
-          })}
-          content={formatMessage({
-            id: `ruleImplementation.actions.restore.confirmation.content`,
-          })}
-          onConfirm={() => handleStatusChange(id, { restore: true, deleted })}
-          onOpen={(e) => e.stopPropagation()}
-          onClose={(e) => e.stopPropagation()}
-        />
-      )}
-      <ConfirmModal
-        icon="trash"
-        trigger={
-          active ? (
-            <Icon name="folder open outline" />
-          ) : (
-            <Icon name="trash alternate outline" color="red" />
-          )
-        }
-        header={formatMessage({
-          id: `ruleImplementation.actions.${mode}.confirmation.header`,
-        })}
-        content={formatMessage(
-          { id: `ruleImplementation.actions.${mode}.confirmation.content` },
-          {
-            action: formatMessage({
-              id: `ruleImplementation.actions.${mode}`,
-            }),
-            mode: formatMessage(
-              { id: `ruleImplementation.${mode}.folder` },
-              // eslint-disable-next-line react/display-name
-              { span: (str) => <span className="highlighted">{str}</span> }
-            ),
-          }
-        )}
-        onConfirm={() =>
-          handleStatusChange(id, { softDelete: active, deleted })
-        }
-        onOpen={(e) => e.stopPropagation()}
-        onClose={(e) => e.stopPropagation()}
-      />
-    </>
-  );
-};
-
-ActionsCell.propTypes = {
-  id: PropTypes.number,
-  deleted_at: PropTypes.string,
-  handleStatusChange: PropTypes.func,
-};
+const UserSearchFiltersLoader = React.lazy(() =>
+  import("@truedat/dd/components/UserSearchFiltersLoader")
+);
 
-export const Implementations = ({
-  deletedRender,
-  setRuleImplementationStatus,
-  manageRuleImplementationAction,
-  rule,
-}) => {
-  const handleStatusChange = (id, mode) =>
-    setRuleImplementationStatus({ id, ruleId: rule?.id, ...mode });
-  const additionalColumns = manageRuleImplementationAction
-    ? [<Table.HeaderCell key={"status"} width={1} />]
-    : [];
-  const additionalCells = manageRuleImplementationAction
-    ? [
-        {
-          style: { textAlign: "center", padding: "1px" },
-          className: "pointer",
-          props: { deletedRender, handleStatusChange },
-          content: ActionsCell,
-        },
-      ]
-    : [];
-  return (
-    <RuleImplementationsTable
-      withoutColumns={["rule", "business_concept"]}
-      additionalCells={additionalCells}
-      additionalColumns={additionalColumns}
-    />
-  );
-};
+export const Implementations = ({ defaultFilters }) => (
+  <>
+    <ImplementationFiltersLoader defaultFilters={defaultFilters} />
+    <UserSearchFiltersLoader scope="rule_implementation" />
+    <RuleImplementationsLoader defaultFilters={defaultFilters} />
+    <ImplementationSearchResults />
+  </>
+);
 
 Implementations.propTypes = {
-  deletedRender: PropTypes.bool,
-  setRuleImplementationStatus: PropTypes.func,
-  manageRuleImplementationAction: PropTypes.bool,
-  rule: PropTypes.object,
+  defaultFilters: PropTypes.object,
 };
 
-const mapStateToProps = ({
-  ruleImplementations,
-  userRulePermissions,
-  rule,
-}) => ({
-  ruleImplementations,
-  manageRuleImplementationAction: _.prop("manage_quality_rule_implementations")(
-    userRulePermissions
-  ),
-  rule,
-});
-
-export default connect(mapStateToProps, { setRuleImplementationStatus })(
-  Implementations
-);
+export default Implementations;