@truedat/dq 4.40.0 → 4.40.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [4.40.3] 2022-03-14
+
+### Added
+
+- [TD-4271] Support for linking implementations with business_concepts
+
+## [4.40.1] 2022-03-08
+
+### Changed
+
+- [TD-4604] Use actions from `POST /api/implementations/search` instead of
+  fetching permissions
+
 ## [4.39.0] 2022-03-01
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.40.0",
+  "version": "4.40.3",
   "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.39.0",
+    "@truedat/test": "4.40.3",
     "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.40.0",
-    "@truedat/df": "4.40.0",
+    "@truedat/core": "4.40.3",
+    "@truedat/df": "4.40.3",
     "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": "0bd677584da73a5021a5c96f2e5525fde9a1958a"
+  "gitHead": "03104a28941b568007ad53b85874ff58225eaa6a"
 }

package/src/components/ImplementationsRoutes.js

@@ -8,9 +8,6 @@ import RuleImplementationsLoader from "./RuleImplementationsLoader";
 const TemplatesLoader = React.lazy(() =>
   import("@truedat/df/templates/components/TemplatesLoader")
 );
-const UserDomainsLoader = React.lazy(() =>
-  import("@truedat/auth/users/components/UserDomainsLoader")
-);
 const UserSearchFiltersLoader = React.lazy(() =>
   import("@truedat/dd/components/UserSearchFiltersLoader")
 );
@@ -24,7 +21,6 @@ const ImplementationsRoutes = () => (
         <ImplementationFiltersLoader />
         <TemplatesLoader scope="qe" />
         <UserSearchFiltersLoader scope="rule_implementation" />
-        <UserDomainsLoader permissions={["manage_rule_results"]} />
         <RuleImplementations exact />
       </>
     )}

package/src/components/RuleImplementationTabs.js

@@ -8,8 +8,9 @@ import { connect } from "react-redux";
 import { FormattedMessage } from "react-intl";
 import {
   RULE_IMPLEMENTATION_EVENTS,
-  RULE_IMPLEMENTATION_RESULTS_DETAILS,
+  IMPLEMENTATION_CONCEPT_LINKS,
   RULE_IMPLEMENTATION_MOVE,
+  RULE_IMPLEMENTATION_RESULTS_DETAILS,
   RULE_IMPLEMENTATION_RESULTS,
   RULE_IMPLEMENTATION,
   linkTo,
@@ -37,6 +38,18 @@ export const RuleImplementationTabs = ({ rule, ruleImplementation, match }) => {
       >
         <FormattedMessage id="tabs.dq.ruleImplementation" />
       </Menu.Item>
+
+      <Menu.Item
+        active={match.path === IMPLEMENTATION_CONCEPT_LINKS}
+        as={Link}
+        to={linkTo.IMPLEMENTATION_CONCEPT_LINKS({
+          id: rule.id,
+          implementation_id: ruleImplementation.id,
+        })}
+      >
+        <FormattedMessage id="tabs.dq.implementation.links" />
+      </Menu.Item>
+
       <Menu.Item
         active={match.path === RULE_IMPLEMENTATION_RESULTS}
         as={Link}

package/src/components/RuleImplementationsActions.js

@@ -14,18 +14,19 @@ import ExecutionPopup from "./ExecutionPopup";
 import RuleImplementationsOptions from "./RuleImplementationsOptions";
 
 export const RuleImplementationsActions = ({
+  actions,
   addImplementationFilter,
   canExecute,
-  executeImplementationsOn,
-  toggleImplementationFilterValue,
-  removeImplementationFilter,
   createExecutionGroup,
-  selectedImplementations,
+  executeImplementationsOn,
   implementationQuery,
-  setMode,
   implementationsExecution,
+  removeImplementationFilter,
   ruleImplementationCount,
   ruleImplementationsLoading,
+  selectedImplementations,
+  setMode,
+  toggleImplementationFilterValue,
 }) => {
   const showExecutableInfo = () => {
     addImplementationFilter({ filter: "executable" });
@@ -50,6 +51,8 @@ export const RuleImplementationsActions = ({
       : { filters: { id: selectedImplementations } };
     createExecutionGroup({ ...query, df_content });
   };
+
+  const canUploadResults = !!actions?.uploadResults;
   return (
     <div style={{ float: "right" }}>
       {implementationsExecution && canExecute && (
@@ -73,24 +76,28 @@ export const RuleImplementationsActions = ({
           />
         </>
       )}
-      <RuleImplementationsOptions loading={ruleImplementationsLoading} />
+      <RuleImplementationsOptions
+        loading={ruleImplementationsLoading}
+        canUploadResults={canUploadResults}
+      />
     </div>
   );
 };
 
 RuleImplementationsActions.propTypes = {
+  actions: PropTypes.object,
   addImplementationFilter: PropTypes.func,
   canExecute: PropTypes.bool,
   createExecutionGroup: PropTypes.func,
   executeImplementationsOn: PropTypes.bool,
-  implementationsExecution: PropTypes.bool,
   implementationQuery: PropTypes.object,
+  implementationsExecution: PropTypes.bool,
   removeImplementationFilter: PropTypes.func,
   ruleImplementationCount: PropTypes.number,
+  ruleImplementationsLoading: PropTypes.bool,
   selectedImplementations: PropTypes.array,
   setMode: PropTypes.func,
   toggleImplementationFilterValue: PropTypes.func,
-  ruleImplementationsLoading: PropTypes.bool,
 };
 
 const mapStateToProps = (state) => ({
@@ -98,6 +105,7 @@ const mapStateToProps = (state) => ({
   ruleImplementationCount: state.ruleImplementationCount,
   implementationsExecution: getImplementationsExecution(state),
   ruleImplementationsLoading: state.ruleImplementationsLoading,
+  actions: state.implementationsActions,
 });
 
 export default connect(mapStateToProps, {

package/src/components/RuleImplementationsOptions.js

@@ -5,7 +5,7 @@ import RuleImplementationsDownload from "./RuleImplementationsDownload";
 import RuleResultsUpload from "./RuleResultsUpload";
 import ImplementationsUploadButton from "./ImplementationsUploadButton";
 
-export const RuleImplementationsOptions = ({ loading }) => (
+export const RuleImplementationsOptions = ({ loading, canUploadResults }) => (
   <Dropdown
     icon="ellipsis vertical"
     className="button icon group-actions button-update"
@@ -16,13 +16,14 @@ export const RuleImplementationsOptions = ({ loading }) => (
     <Dropdown.Menu>
       <RuleImplementationsDownload />
       <ImplementationsUploadButton />
-      <RuleResultsUpload />
+      {canUploadResults ? <RuleResultsUpload /> : null}
     </Dropdown.Menu>
   </Dropdown>
 );
 
 RuleImplementationsOptions.propTypes = {
   loading: PropTypes.bool,
+  canUploadResults: PropTypes.bool,
 };
 
 export default RuleImplementationsOptions;

package/src/components/RuleImplementationsTable.js

@@ -132,9 +132,12 @@ RuleImplementationsTable.propTypes = {
   withoutColumns: PropTypes.array,
 };
 
-const mapStateToProps = (state) => ({
+const mapStateToProps = (state, props) => ({
   columns: getRuleImplementationColumns(state),
-  ruleImplementations: state.ruleImplementations,
+  ruleImplementations: _.getOr(
+    state.ruleImplementations,
+    "ruleImplementations"
+  )(props),
   ruleImplementationsLoading: state.ruleImplementationsLoading,
   implementationsSort: _.path("ruleImplementationQuery.sort")(state),
 });

package/src/components/RuleResultsUpload.js

@@ -1,5 +1,4 @@
-import _ from "lodash/fp";
-import React, { useEffect, useState } from "react";
+import React from "react";
 import PropTypes from "prop-types";
 import { connect } from "react-redux";
 import { Dropdown } from "semantic-ui-react";
@@ -7,31 +6,18 @@ import { useIntl } from "react-intl";
 import { UploadModal } from "@truedat/core/components";
 import { uploadResults } from "../routines";
 
-export const RuleResultsUpload = ({ uploadResults, loading, userDomains }) => {
+export const RuleResultsUpload = ({ uploadResults, loading }) => {
   const { formatMessage } = useIntl();
-  const [permissionFound, setPermissionFound] = useState(false);
-
-  useEffect(() => {
-    setPermissionFound(
-      !_.flow(
-        _.find({ permission: "manage_rule_results" }),
-        _.path("domains"),
-        _.isEmpty
-      )(userDomains)
-    );
-  }, [userDomains]);
 
   return (
     <UploadModal
       icon="upload"
       trigger={
-        permissionFound ? (
-          <Dropdown.Item
-            icon="upload"
-            text={formatMessage({ id: "ruleResults.actions.upload.tooltip" })}
-            disabled={loading}
-          />
-        ) : null
+        <Dropdown.Item
+          icon="upload"
+          text={formatMessage({ id: "ruleResults.actions.upload.tooltip" })}
+          disabled={loading}
+        />
       }
       header={formatMessage({
         id: "ruleResults.actions.upload.confirmation.header",
@@ -52,14 +38,10 @@ export const RuleResultsUpload = ({ uploadResults, loading, userDomains }) => {
 RuleResultsUpload.propTypes = {
   uploadResults: PropTypes.func,
   loading: PropTypes.bool,
-  userDomains: PropTypes.array,
 };
 
-const mapStateToProps = (state) => {
-  return {
-    loading: state.uploadingResults,
-    userDomains: state.userDomains,
-  };
-};
+const mapStateToProps = ({ resultsUploading: loading }) => ({
+  loading,
+});
 
 export default connect(mapStateToProps, { uploadResults })(RuleResultsUpload);

package/src/components/RuleRoutes.js

@@ -10,14 +10,16 @@ import {
   RULE,
   RULE_EDIT,
   RULE_EVENTS,
-  RULE_IMPLEMENTATION_RESULT_DETAILS,
-  RULE_IMPLEMENTATION_RESULTS_DETAILS,
-  RULE_IMPLEMENTATION,
-  RULE_IMPLEMENTATION_EVENTS,
-  RULE_IMPLEMENTATION_NEW,
   RULE_IMPLEMENTATION_CLONE,
   RULE_IMPLEMENTATION_EDIT,
+  RULE_IMPLEMENTATION_EVENTS,
+  IMPLEMENTATION_CONCEPT_LINKS,
+  IMPLEMENTATION_CONCEPT_LINKS_NEW,
   RULE_IMPLEMENTATION_MOVE,
+  RULE_IMPLEMENTATION_NEW,
+  RULE_IMPLEMENTATION_RESULT_DETAILS,
+  RULE_IMPLEMENTATION_RESULTS_DETAILS,
+  RULE_IMPLEMENTATION,
   RULE_NEW,
   RULE_IMPLEMENTATION_RESULTS,
   RULE_IMPLEMENTATIONS,
@@ -60,6 +62,13 @@ const TemplatesLoader = React.lazy(() =>
 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 QualityTemplatesLoader = () => <TemplatesLoader scope="dq" />;
 const ImplementationTemplatesLoader = () => <TemplatesLoader scope="ri" />;
 
@@ -285,6 +294,40 @@ export const RuleRoutes = ({
                     </>
                   )}
                 />
+                <Route
+                  exact
+                  path={IMPLEMENTATION_CONCEPT_LINKS}
+                  render={() => (
+                    <>
+                      <RuleCrumbs />
+                      <Segment>
+                        <RuleImplementationLoader />
+                        {ruleLoaded && ruleImplementationLoaded && (
+                          <RuleImplementation>
+                            <ImplementationLinks />
+                          </RuleImplementation>
+                        )}
+                      </Segment>
+                    </>
+                  )}
+                />
+                <Route
+                  exact
+                  path={IMPLEMENTATION_CONCEPT_LINKS_NEW}
+                  render={() => (
+                    <>
+                      <RuleCrumbs />
+                      <Segment>
+                        <RuleImplementationLoader />
+                        {ruleLoaded && ruleImplementationLoaded && (
+                          <RuleImplementation>
+                            <ImplementationRelationForm />
+                          </RuleImplementation>
+                        )}
+                      </Segment>
+                    </>
+                  )}
+                />
                 <Route
                   exact
                   path={RULE_IMPLEMENTATION_RESULTS}

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

@@ -19,16 +19,17 @@ const state = {
 const renderOpts = {
   messages: {
     en: {
-      "tabs.dq.ruleImplementation.results": "results",
-      "tabs.dq.ruleImplementation": "implementation",
-      "tabs.dq.ruleImplementation.audit": "events",
+      "quality.result.no.data": "No information about quality",
       "ruleImplementation.actions.clone": "clone",
-      "ruleImplementation.actions.move": "move",
-      "ruleImplementation.actions.edit": "edit",
-      "ruleImplementation.actions.deprecate": "archive",
-      "ruleImplementation.actions.delete.confirmation.header": "header",
       "ruleImplementation.actions.delete.confirmation.content": "confirm",
-      "quality.result.no.data": "No information about quality",
+      "ruleImplementation.actions.delete.confirmation.header": "header",
+      "ruleImplementation.actions.deprecate": "archive",
+      "ruleImplementation.actions.edit": "edit",
+      "ruleImplementation.actions.move": "move",
+      "tabs.dq.implementation.links": "Related concepts",
+      "tabs.dq.ruleImplementation.audit": "events",
+      "tabs.dq.ruleImplementation.results": "results",
+      "tabs.dq.ruleImplementation": "implementation",
     },
   },
   state,

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

@@ -0,0 +1,30 @@
+import React from "react";
+import { render } from "@truedat/test/render";
+import { RuleImplementationTabs } from "../RuleImplementationTabs";
+
+describe("<RuleImplementationTabs />", () => {
+  const renderOpts = {
+    messages: {
+      en: {
+        "tabs.dq.ruleImplementation": "ruleImplementation",
+        "tabs.dq.implementation.links": "links",
+        "tabs.dq.ruleImplementation.results": "results",
+        "tabs.dq.ruleImplementation.details": "details",
+        "tabs.dq.ruleImplementation.audit": "audit",
+      },
+    },
+  };
+
+  const props = {
+    rule: { id: 8 },
+    ruleImplementation: { id: 1 },
+    match: { path: "" },
+  };
+  it("matches the latest snapshot", () => {
+    const { container } = render(
+      <RuleImplementationTabs {...props} />,
+      renderOpts
+    );
+    expect(container).toMatchSnapshot();
+  });
+});

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

@@ -12,6 +12,7 @@ describe("<RuleImplementationsActions />", () => {
   const setMode = jest.fn();
   const removeImplementationFilter = jest.fn();
   const props = {
+    actions: { uploadResults: {} },
     canExecute: true,
     executionGroupLoading: false,
     ruleImplementationCount: 12,
@@ -23,6 +24,7 @@ describe("<RuleImplementationsActions />", () => {
     setMode,
     removeImplementationFilter,
   };
+
   it("matches the latest snapshot", () => {
     const wrapper = shallow(<RuleImplementationsActions {...props} />);
     expect(wrapper).toMatchSnapshot();

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

@@ -1,18 +1,22 @@
-import _ from "lodash/fp";
 import React from "react";
-import { shallow } from "enzyme";
-import { intl } from "@truedat/test/intl-stub";
-import { RuleImplementationsOptions } from "../RuleImplementationsOptions";
+import { waitFor } from "@testing-library/react";
+import { render } from "@truedat/test/render";
+import coreEn from "@truedat/core/messages/en";
+import RuleImplementationsOptions from "../RuleImplementationsOptions";
+import en from "../../messages/en";
 
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
+const renderOpts = {
+  messages: { en: { ...coreEn, ...en } },
+};
+
+const props = { canUploadResults: true };
 
 describe("<RuleImplementationsOptions />", () => {
-  it("matches the latest snapshot", () => {
-    const wrapper = shallow(<RuleImplementationsOptions />);
-    expect(wrapper).toMatchSnapshot();
-  });
-  it("matches the latest loading snapshot", () => {
-    const wrapper = shallow(<RuleImplementationsOptions loading />);
-    expect(wrapper).toMatchSnapshot();
+  it("matches the latest snapshot", async () => {
+    const { container } = render(
+      <RuleImplementationsOptions {...props} />,
+      renderOpts
+    );
+    await waitFor(() => expect(container).toMatchSnapshot());
   });
 });

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

@@ -1,73 +1,15 @@
 import React from "react";
-import { intl } from "@truedat/test/intl-stub";
-import { IntlProvider } from "react-intl";
+import { waitFor } from "@testing-library/react";
 import { render } from "@truedat/test/render";
-import { shallow } from "enzyme";
-import { RuleResultsUpload } from "../RuleResultsUpload";
+import coreEn from "@truedat/core/messages/en";
+import RuleResultsUpload from "../RuleResultsUpload";
+import en from "../../messages/en";
 
-afterEach(() => {    
-  jest.clearAllMocks();
-});
+const renderOpts = { messages: { en: { ...coreEn, ...en } } };
 
 describe("<RuleResultsUpload />", () => {
-  const renderOpts = {
-    messages: {
-      en: {
-        "ruleResults.actions.upload.tooltip": "Upload rule results",
-        "ruleResults.actions.upload.confirmation.header": "Upload rule results",
-        "uploadModal.actions.upload.confirmation.content": "Drag an drop file or click to select file",
-        "ruleResults.actions.upload.confirmation.header": "Upload rule results",
-      },
-    },
-  };
-
-  it("matches the latest snapshot", () => {
-    const spy = jest.spyOn(React, "useContext").mockImplementation(() => intl);
-    const props = {
-      uploadResults: jest.fn(),
-      loading: false,
-    };
-    const wrapper = shallow(<RuleResultsUpload {...props} />);
-    expect(wrapper).toMatchSnapshot();
-    spy.mockRestore();
-  });
-
-  it("Renders upload rule results menu item if there is a domain with manage_rule_results permission", () => {
-    const props = {
-      uploadResults: jest.fn(),
-      loading: false,
-      userDomains: [
-        {
-          domains: [
-            {
-              external_id: "Truedat",
-              id: 2,
-              name: "Truedat",
-            },
-          ],
-          permission: "manage_rule_results",
-        },
-      ],
-    };
-    const { getByText } = render(<RuleResultsUpload {...props} />, renderOpts);
-
-    const element = getByText("Upload rule results");
-    expect(element).toBeInTheDocument()
-  });
-
-  it("Does not render upload rule results menu item if there is no domain with manage_rule_results permission", () => {
-    const props = {
-      uploadResults: jest.fn(),
-      loading: false,
-      userDomains: [],
-    };
-
-    const { queryByText } = render(
-      <RuleResultsUpload {...props} />,
-      renderOpts
-    );
-
-    const element = queryByText("Upload rule results");
-    expect(element).toBeNull();
+  it("matches the latest snapshot", async () => {
+    const { container } = render(<RuleResultsUpload />, renderOpts);
+    await waitFor(() => expect(container).toMatchSnapshot());
   });
 });

package/src/components/__tests__/__snapshots__/RuleImplementation.spec.js.snap

@@ -134,6 +134,12 @@ exports[`<RuleImplementation /> matches the latest snapshot 1`] = `
     >
       implementation
     </a>
+    <a
+      class="item"
+      href="/rules/1/implementations/1/links"
+    >
+      Related concepts
+    </a>
     <a
       class="item"
       href="/rules/1/implementations/1/results"

package/src/components/__tests__/__snapshots__/RuleImplementationTabs.spec.js.snap

@@ -0,0 +1,34 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`<RuleImplementationTabs /> matches the latest snapshot 1`] = `
+<div>
+  <div
+    class="ui pointing secondary top attached tabular menu"
+  >
+    <a
+      class="item"
+      href="/rules/8/implementations/1"
+    >
+      ruleImplementation
+    </a>
+    <a
+      class="item"
+      href="/rules/8/implementations/1/links"
+    >
+      links
+    </a>
+    <a
+      class="item"
+      href="/rules/8/implementations/1/results"
+    >
+      results
+    </a>
+    <a
+      class="item"
+      href="/rules/8/implementations/1/events"
+    >
+      audit
+    </a>
+  </div>
+</div>
+`;

package/src/components/__tests__/__snapshots__/RuleImplementationsActions.spec.js.snap

@@ -28,6 +28,7 @@ exports[`<RuleImplementationsActions /> matches the latest snapshot 1`] = `
     handleSubmit={[Function]}
   />
   <RuleImplementationsOptions
+    canUploadResults={true}
     loading={false}
   />
 </div>

package/src/components/__tests__/__snapshots__/RuleImplementationsOptions.spec.js.snap

@@ -1,58 +1,67 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`<RuleImplementationsOptions /> matches the latest loading snapshot 1`] = `
-<Dropdown
-  additionLabel="Add "
-  additionPosition="top"
-  className="button icon group-actions button-update"
-  closeOnBlur={true}
-  closeOnEscape={true}
-  deburr={false}
-  direction="left"
-  disabled={true}
-  floating={true}
-  icon="ellipsis vertical"
-  minCharacters={1}
-  noResultsMessage="No results found."
-  openOnFocus={true}
-  renderLabel={[Function]}
-  searchInput="text"
-  selectOnBlur={true}
-  selectOnNavigation={true}
-  wrapSelection={true}
->
-  <DropdownMenu>
-    <Connect(RuleImplementationsDownload) />
-    <Connect(ImplementationsUploadButton) />
-    <Connect(RuleResultsUpload) />
-  </DropdownMenu>
-</Dropdown>
-`;
-
 exports[`<RuleImplementationsOptions /> matches the latest snapshot 1`] = `
-<Dropdown
-  additionLabel="Add "
-  additionPosition="top"
-  className="button icon group-actions button-update"
-  closeOnBlur={true}
-  closeOnEscape={true}
-  deburr={false}
-  direction="left"
-  floating={true}
-  icon="ellipsis vertical"
-  minCharacters={1}
-  noResultsMessage="No results found."
-  openOnFocus={true}
-  renderLabel={[Function]}
-  searchInput="text"
-  selectOnBlur={true}
-  selectOnNavigation={true}
-  wrapSelection={true}
->
-  <DropdownMenu>
-    <Connect(RuleImplementationsDownload) />
-    <Connect(ImplementationsUploadButton) />
-    <Connect(RuleResultsUpload) />
-  </DropdownMenu>
-</Dropdown>
+<div>
+  <div
+    aria-expanded="false"
+    class="ui floating dropdown button icon group-actions button-update"
+    role="listbox"
+    tabindex="0"
+  >
+    <i
+      aria-hidden="true"
+      class="ellipsis vertical icon"
+    />
+    <div
+      class="menu transition left"
+    >
+      <div
+        aria-disabled="true"
+        class="disabled item"
+        role="option"
+      >
+        <i
+          aria-hidden="true"
+          class="download icon"
+        />
+        <span>
+          Download with csv format
+        </span>
+        <p
+          class="menu-item-description"
+        >
+          There are no Implementations to be downloaded
+        </p>
+      </div>
+      <div
+        class="item"
+        role="option"
+      >
+        <i
+          aria-hidden="true"
+          class="upload icon"
+        />
+        <span
+          class="text"
+        >
+          Upload Implementations
+        </span>
+      </div>
+      <div
+        class="item"
+        role="option"
+      >
+        <i
+          aria-hidden="true"
+          class="upload icon"
+        />
+        <span
+          class="text"
+        >
+          Upload rule results
+        </span>
+      </div>
+    </div>
+  </div>
+</div>
 `;

package/src/components/__tests__/__snapshots__/RuleResultsUpload.spec.js.snap

@@ -1,12 +1,20 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`<RuleResultsUpload /> matches the latest snapshot 1`] = `
-<UploadModal
-  content="uploadModal.actions.upload.confirmation.content"
-  handleSubmit={[Function]}
-  header="ruleResults.actions.upload.confirmation.header"
-  icon="upload"
-  param="rule_results"
-  trigger={null}
-/>
+<div>
+  <div
+    class="item"
+    role="option"
+  >
+    <i
+      aria-hidden="true"
+      class="upload icon"
+    />
+    <span
+      class="text"
+    >
+      Upload rule results
+    </span>
+  </div>
+</div>
 `;

package/src/messages/en.js

@@ -419,6 +419,7 @@ export default {
   "ruleImplementation.props.system.placeholder": "System",
   "ruleImplementation.props.type": "Type",
   "ruleImplementation.props.type.placeholder": "Type",
+  "ruleImplementations.relation.new.header": "Link to Concept",
   "ruleImplementation.summary.database": "Database",
   "ruleImplementation.summary.dataset": "Dataset",
   "ruleImplementation.summary.field": "Field",
@@ -561,6 +562,7 @@ export default {
   "structureFields.dropdown.label": "Select Field",
   "structureFields.dropdown.placeholder": "Fields",
   "summary.link.and": "and",
+  "tabs.dq.implementation.links": "Link to concepts",
   "tabs.dq.rule": "Rule",
   "tabs.dq.rule.audit": "Audit",
   "tabs.dq.ruleImplementation": "Implementation",

package/src/messages/es.js

@@ -5,7 +5,8 @@ export default {
   "actions.prev": "Anterior",
   "actions.save": "Guardar",
   "actions.submit": "Guardar",
-  "alert.deleteRuleImplementation.failed.header": "Error al archivar implementación",
+  "alert.deleteRuleImplementation.failed.header":
+    "Error al archivar implementación",
   "alert.createExecutionGroup.success.content":
     "Se ha solicitado la ejecución de {count} implementaciones",
   "alert.createExecutionGroup.success.header": "Ejecuciones programadas",
@@ -27,7 +28,7 @@ export default {
   "dataset.form.button.add_structure": "Añadir Estructura",
   "datasetForm.implementation_key.tooltip":
     "En caso de no introducir clave de implementación, se autogenerará al guardar la implementación",
-  "executionGroup": "Ejecuciones",
+  executionGroup: "Ejecuciones",
   "executions.completed.content": "Se han ejecutado {count} implementaciones.",
   "executions.completed.header": "Ejecuciones finalizadas",
   "executions.pending.content":
@@ -189,8 +190,10 @@ export default {
   "rule.props.name": "Nombre",
   "rule.props.type_params.placeholder": "Parametros a cumplimentar",
   "rule.props.type_params": "Parametros",
-  "rule.props.type.placeholder": "Rango de valores",
   "rule.props.type": "Tipo de regla",
+  "rule.props.type.placeholder": "Rango de valores",
+  "ruleImplementations.relation.new.header":
+    "Vas a vincular esta implementación a un término de glosario",
   "rule.ruleImplementation.results.details.empty":
     "No existen detalles para este resultado",
   "rule.ruleImplementation.results.empty":
@@ -477,10 +480,12 @@ export default {
   "ruleImplementations.actions.create": "Crear nueva implementación",
   "ruleImplementations.actions.edit": "Editar implementación",
   "ruleImplementations.actions.popup.deprecated": "Implementaciones Archivadas",
-  "ruleImplementations.events.action_created": "Implementación creada en regla: {0}",
+  "ruleImplementations.events.action_created":
+    "Implementación creada en regla: {0}",
   "ruleImplementations.events.action_changed": "Campo {0} actualizado a {1}",
   "ruleImplementations.events.action_deprecated": "Implementación archivada",
-  "ruleImplementations.events.action_moved": "Implementación movida a la regla: {0}",
+  "ruleImplementations.events.action_moved":
+    "Implementación movida a la regla: {0}",
   "ruleImplementations.events.action_restored": "Implementación restaurada",
   "ruleImplementations.events.action_updated": "Implementación actualizada",
   "ruleImplementations.header": "Implementaciones de calidad",
@@ -512,7 +517,8 @@ export default {
   "ruleImplementations.props.status": "Estado",
   "ruleImplementations.props.template": "Plantilla",
   "ruleImplementations.props.rule_template": "Plantilla de regla",
-  "ruleImplementations.props.implementation_template": "Plantilla de implementación",
+  "ruleImplementations.props.implementation_template":
+    "Plantilla de implementación",
   "ruleImplementations.retrieved.results":
     "{count} implementaciones encontradas",
   "ruleImplementations.search.results.empty":
@@ -560,10 +566,12 @@ export default {
   "rules.events.action_changed": "Campo {0} actualizado: {1}",
   "rules.events.action_changed_to": "Campo {0} actualizado a {1}",
   "rules.events.action_updated": "Regla actualizada",
-  "ruleImplementations.events.action_created": "Implementación creada en regla: {0}",
+  "ruleImplementations.events.action_created":
+    "Implementación creada en regla: {0}",
   "ruleImplementations.events.action_changed": "Campo {0} actualizado a {1}",
   "ruleImplementations.events.action_deprecated": "Implementación archivada",
-  "ruleImplementations.events.action_moved": "Implementación movida a la regla: {0}",
+  "ruleImplementations.events.action_moved":
+    "Implementación movida a la regla: {0}",
   "rules.retrieved.results": "{count} reglas encontradas",
   "rules.search.placeholder": "Buscar reglas...",
   "rules.searching": "Buscando...",
@@ -580,6 +588,7 @@ export default {
   "structureFields.dropdown.label": "Seleccionar Campo",
   "structureFields.dropdown.placeholder": "Campos",
   "summary.link.and": "y",
+  "tabs.dq.implementation.links": "Conceptos relacionados",
   "tabs.dq.rule": "Regla",
   "tabs.dq.rule.audit": "Auditoría",
   "tabs.dq.ruleImplementation.audit": "Auditoría",

package/src/reducers/__tests__/implementationActions.spec.js

@@ -0,0 +1,44 @@
+import {
+  clearRuleImplementations,
+  fetchRuleImplementation,
+} from "../../routines";
+import { implementationActions } from "..";
+
+const fooState = { foo: "bar" };
+
+describe("reducers: implementationActions", () => {
+  const initialState = {};
+
+  it("should provide the initial state", () => {
+    expect(implementationActions(undefined, {})).toEqual(initialState);
+  });
+
+  it("should handle the clearRuleImplementations.TRIGGER action", () => {
+    expect(
+      implementationActions(fooState, {
+        type: clearRuleImplementations.TRIGGER,
+      })
+    ).toEqual(initialState);
+  });
+
+  it("should handle the fetchRuleImplementation.SUCCESS action", () => {
+    const actions = { action1: { href: "1" } };
+    const payload = {
+      id: 2,
+      implementation_key: "xxx",
+      results: [],
+      _actions: actions,
+    };
+
+    expect(
+      implementationActions(fooState, {
+        type: fetchRuleImplementation.SUCCESS,
+        payload,
+      })
+    ).toMatchObject(actions);
+  });
+
+  it("should ignore unknown actions", () => {
+    expect(implementationActions(fooState, { type: "FOO" })).toBe(fooState);
+  });
+});

package/src/reducers/__tests__/implementationLinks.spec.js

@@ -0,0 +1,62 @@
+import { deleteRelation } from "@truedat/lm/routines";
+import {
+  clearRuleImplementation,
+  fetchRuleImplementation,
+} from "../../routines";
+import { implementationLinks } from "..";
+
+const fooState = { foo: "bar" };
+
+describe("reducers: implementationLinks", () => {
+  const initialState = [];
+
+  it("should provide the initial state", () => {
+    expect(implementationLinks(undefined, {})).toEqual(initialState);
+  });
+
+  it("should handle the clearRuleImplementation.TRIGGER action", () => {
+    expect(
+      implementationLinks(fooState, { type: clearRuleImplementation.TRIGGER })
+    ).toEqual(initialState);
+  });
+
+  it("should handle the fetchRuleImplementation.TRIGGER action", () => {
+    expect(
+      implementationLinks(fooState, { type: fetchRuleImplementation.TRIGGER })
+    ).toEqual(initialState);
+  });
+
+  it("should handle the fetchRuleImplementation.SUCCESS action", () => {
+    const links = [{ name: "link1" }, { name: "link2" }];
+    const data = {
+      id: 2,
+      implementation_key: "xxx",
+      results: [],
+      links,
+    };
+    const payload = { data };
+
+    expect(
+      implementationLinks(fooState, {
+        type: fetchRuleImplementation.SUCCESS,
+        payload,
+      })
+    ).toMatchObject(links);
+  });
+
+  it("should filter deleted id on deleteRelation.SUCCESS action", () => {
+    const links = [{ id: "1" }, { id: "2" }];
+    const payload = { id: "1" };
+
+    expect(
+      implementationLinks(links, {
+        type: deleteRelation.SUCCESS,
+        payload,
+      })
+    ).toMatchObject([{ id: "2" }]);
+  });
+
+  it("should ignore unknown actions", () => {
+    expect(implementationLinks(fooState, { type: "FOO" })).toBe(fooState);
+  });
+});

package/src/reducers/__tests__/implementationsActions.spec.js

@@ -0,0 +1,50 @@
+import {
+  clearRuleImplementations,
+  searchRuleImplementations,
+} from "../../routines";
+import {
+  implementationsActions,
+  initialState,
+} from "../implementationsActions";
+
+const fooState = { foo: "bar" };
+const payload = {};
+
+describe("reducers: implementationsActions", () => {
+  it("should provide the initial state", () => {
+    expect(implementationsActions(undefined, {})).toBe(initialState);
+  });
+
+  it("should be the initial state after receiving the clearRuleImplementations.TRIGGER action", () => {
+    expect(
+      implementationsActions(fooState, {
+        type: clearRuleImplementations.TRIGGER,
+        payload,
+      })
+    ).toBe(initialState);
+  });
+
+  it("should be the initial state after receiving the searchRuleImplementations.TRIGGER action", () => {
+    expect(
+      implementationsActions(fooState, {
+        type: searchRuleImplementations.TRIGGER,
+        payload,
+      })
+    ).toBe(initialState);
+  });
+
+  it("should extract _actions from the searchRuleImplementations.SUCCESS action", () => {
+    const _actions = { uploadResults: { foo: "bar" } };
+    const payload = { data: { _actions } };
+    expect(
+      implementationsActions(fooState, {
+        type: searchRuleImplementations.SUCCESS,
+        payload,
+      })
+    ).toMatchObject(_actions);
+  });
+
+  it("should ignore unhandled actions", () => {
+    expect(implementationsActions(fooState, { type: "FOO" })).toBe(fooState);
+  });
+});

package/src/reducers/__tests__/{uploadingResults.spec.js → resultsUploading.spec.js}

@@ -1,18 +1,18 @@
 import { uploadResults } from "../../routines";
-import { uploadingResults } from "..";
+import { resultsUploading } from "../resultsUploading";
 
 const fooState = { foo: "bar" };
 
 const initialState = false;
 
-describe("reducers: uploadingResults", () => {
+describe("reducers: resultsUploading", () => {
   it("should provide the initial state", () => {
-    expect(uploadingResults(undefined, {})).toEqual(initialState);
+    expect(resultsUploading(undefined, {})).toEqual(initialState);
   });
 
   it("should handle the uploadResults.TRIGGER action", () => {
     expect(
-      uploadingResults(fooState, {
+      resultsUploading(fooState, {
         type: uploadResults.TRIGGER,
       })
     ).toBeTruthy();
@@ -20,7 +20,7 @@ describe("reducers: uploadingResults", () => {
 
   it("should handle the uploadResults.FULFILL action", () => {
     expect(
-      uploadingResults(fooState, {
+      resultsUploading(fooState, {
         type: uploadResults.FULFILL,
       })
     ).toBeFalsy();

package/src/reducers/implementationActions.js

@@ -0,0 +1,17 @@
+import _ from "lodash/fp";
+import { clearRuleImplementations, fetchRuleImplementation } from "../routines";
+
+const initialState = {};
+
+const implementationActions = (state = initialState, { type, payload }) => {
+  switch (type) {
+    case fetchRuleImplementation.SUCCESS:
+      return _.pathOr(initialState, "_actions")(payload);
+    case clearRuleImplementations.TRIGGER:
+      return initialState;
+    default:
+      return state;
+  }
+};
+
+export { implementationActions };

package/src/reducers/implementationLinks.js

@@ -0,0 +1,22 @@
+import _ from "lodash/fp";
+import { deleteRelation } from "@truedat/lm/routines";
+import { clearRuleImplementation, fetchRuleImplementation } from "../routines";
+
+const initialState = [];
+
+const implementationLinks = (state = initialState, { type, payload }) => {
+  switch (type) {
+    case clearRuleImplementation.TRIGGER:
+      return initialState;
+    case fetchRuleImplementation.TRIGGER:
+      return initialState;
+    case fetchRuleImplementation.SUCCESS:
+      return _.pathOr([], "data.links")(payload);
+    case deleteRelation.SUCCESS:
+      return _.reject(payload)(state);
+    default:
+      return state;
+  }
+};
+
+export { implementationLinks };

package/src/reducers/implementationsActions.js

@@ -0,0 +1,24 @@
+import {
+  clearRuleImplementations,
+  searchRuleImplementations,
+} from "../routines";
+
+export const initialState = null;
+
+export const implementationsActions = (
+  state = initialState,
+  { type, payload }
+) => {
+  switch (type) {
+    case clearRuleImplementations.TRIGGER:
+      return initialState;
+    case searchRuleImplementations.TRIGGER:
+      return initialState;
+    case searchRuleImplementations.SUCCESS:
+      return payload?.data?._actions || initialState;
+    default:
+      return state;
+  }
+};
+
+export default implementationsActions;

package/src/reducers/index.js

@@ -3,9 +3,13 @@ import { conceptRulesActions } from "./conceptRulesActions";
 import { conceptRulesLoading } from "./conceptRulesLoading";
 import { deletionQuery } from "./deletionQuery";
 import { dqMessage } from "./dqMessage";
-import { previousRuleImplementationQuery } from "./previousRuleImplementationQuery";
-import { executionGroupLoading } from "./executionGroupLoading";
 import { executionGroup } from "./executionGroup";
+import { implementationLinks } from "./implementationLinks";
+import { implementationActions } from "./implementationActions";
+import { executionGroupLoading } from "./executionGroupLoading";
+import { implementationsActions } from "./implementationsActions";
+import { previousRuleImplementationQuery } from "./previousRuleImplementationQuery";
+import { resultsUploading } from "./resultsUploading";
 import { rule } from "./rule";
 import { ruleActions } from "./ruleActions";
 import { ruleActiveFilters } from "./ruleActiveFilters";
@@ -14,6 +18,7 @@ import { ruleCreating } from "./ruleCreating";
 import { ruleFilters } from "./ruleFilters";
 import { ruleFiltersLoading } from "./ruleFiltersLoading";
 import { ruleImplementation } from "./ruleImplementation";
+import { ruleImplementationActiveFilters } from "./ruleImplementationActiveFilters";
 import { ruleImplementationCount } from "./ruleImplementationCount";
 import { ruleImplementationCreating } from "./ruleImplementationCreating";
 import { ruleImplementationFilters } from "./ruleImplementationFilters";
@@ -26,7 +31,6 @@ import { ruleImplementationSaving } from "./ruleImplementationSaving";
 import { ruleImplementationSelectedFilter } from "./ruleImplementationSelectedFilter";
 import { ruleImplementations } from "./ruleImplementations";
 import { ruleImplementationsDownloading } from "./ruleImplementationsDownloading";
-import { ruleImplementationActiveFilters } from "./ruleImplementationActiveFilters";
 import { ruleImplementationsLoading } from "./ruleImplementationsLoading";
 import { ruleImplementationsPageSize } from "./ruleImplementationsPageSize";
 import { ruleLoading } from "./ruleLoading";
@@ -39,10 +43,9 @@ import { rulesLoading } from "./rulesLoading";
 import { rulesPageSize } from "./rulesPageSize";
 import { uploadingImplementationsFile } from "./uploadingImplementationsFile";
 import { uploadingRulesFile } from "./uploadingRulesFile";
+import { userImplementationsPermissions } from "./userImplementationsPermissions";
 import { userRulePermissions } from "./userRulePermissions";
 import { userRulesPermissions } from "./userRulesPermissions";
-import { userImplementationsPermissions } from "./userImplementationsPermissions";
-import { uploadingResults } from "./uploadingResults";
 
 export {
   conceptRules,
@@ -50,9 +53,13 @@ export {
   conceptRulesLoading,
   deletionQuery,
   dqMessage,
-  previousRuleImplementationQuery,
-  executionGroupLoading,
   executionGroup,
+  implementationLinks,
+  implementationActions,
+  executionGroupLoading,
+  implementationsActions,
+  previousRuleImplementationQuery,
+  resultsUploading,
   rule,
   ruleActions,
   ruleActiveFilters,
@@ -84,10 +91,9 @@ export {
   rules,
   rulesLoading,
   rulesPageSize,
-  uploadingRulesFile,
   uploadingImplementationsFile,
+  uploadingRulesFile,
+  userImplementationsPermissions,
   userRulePermissions,
   userRulesPermissions,
-  userImplementationsPermissions,
-  uploadingResults,
 };

package/src/reducers/{uploadingResults.js → resultsUploading.js}

@@ -2,7 +2,7 @@ import { uploadResults } from "../routines";
 
 const initialState = false;
 
-export const uploadingResults = (state = initialState, { type }) => {
+export const resultsUploading = (state = initialState, { type }) => {
   switch (type) {
     case uploadResults.TRIGGER:
       return true;
@@ -13,4 +13,4 @@ export const uploadingResults = (state = initialState, { type }) => {
   }
 };
 
-export default uploadingResults;
+export default resultsUploading;