@truedat/dq 4.56.8 → 4.58.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [4.56.9] 2022-11-12
+
+### Added
+
+- [TD-5161] Create link with concepts once the implementations are created
+
 ## [4.56.7] 2022-11-28
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.56.8",
+  "version": "4.58.0",
   "description": "Truedat Web Data Quality Module",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -34,7 +34,7 @@
     "@testing-library/jest-dom": "^5.16.5",
     "@testing-library/react": "^12.0.0",
     "@testing-library/user-event": "^13.2.1",
-    "@truedat/test": "4.56.8",
+    "@truedat/test": "4.58.0",
     "babel-jest": "^28.1.0",
     "babel-plugin-dynamic-import-node": "^2.3.3",
     "babel-plugin-lodash": "^3.3.4",
@@ -92,8 +92,8 @@
   },
   "dependencies": {
     "@apollo/client": "^3.7.1",
-    "@truedat/core": "4.56.8",
-    "@truedat/df": "4.56.8",
+    "@truedat/core": "4.58.0",
+    "@truedat/df": "4.58.0",
     "graphql": "^15.5.3",
     "moment": "^2.29.4",
     "path-to-regexp": "^1.7.0",
@@ -108,12 +108,13 @@
     "redux-saga-routines": "^3.2.3",
     "reselect": "^4.1.7",
     "semantic-ui-calendar-react": "^0.15.3",
-    "semantic-ui-react": "^2.1.4"
+    "semantic-ui-react": "^2.1.4",
+    "swr": "^1.3.0"
   },
   "peerDependencies": {
     "react": ">= 16.8.6 < 17",
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 2.0.3 < 2.2"
   },
-  "gitHead": "9bf266eb26e4af0b774560d5a88b0f22325495e0"
+  "gitHead": "3987557a127b4e999021e0d7179ad7a6375bfe01"
 }

package/src/components/NewRuleImplementation.js

@@ -1,12 +1,16 @@
 import _ from "lodash/fp";
 import React, { useState } from "react";
 import PropTypes from "prop-types";
+import queryString from "query-string";
 import { connect } from "react-redux";
-import { Divider, Header, Grid } from "semantic-ui-react";
 import { FormattedMessage } from "react-intl";
+import { useLocation } from "react-router-dom";
+import { Divider, Loader, Header, Grid } from "semantic-ui-react";
+import { linkTo } from "@truedat/core/routes";
 import { Loading } from "@truedat/core/components";
 import { useOperators } from "@truedat/core/hooks";
 import { getFieldType } from "@truedat/core/services/fieldType";
+import { useConcept } from "../hooks/useConcept";
 import {
   createRuleImplementation,
   updateRuleImplementation,
@@ -245,6 +249,10 @@ const withConditionDefaultAlias = (conditions, structures) =>
   })(conditions);
 
 export const NewRuleImplementation = ({
+  conceptDomainId,
+  conceptDomainIds,
+  conceptId,
+  conceptVersionId,
   clone = false,
   createRuleImplementation,
   updateRuleImplementation,
@@ -353,7 +361,7 @@ export const NewRuleImplementation = ({
           minimum: null,
           goal: null,
           rule_id: _.propOr(null, "id")(rule),
-          domain_id: _.propOr(null, "domain_id")(rule),
+          domain_id: conceptDomainId || rule?.domain_id || null,
           rule: rule,
         }
   );
@@ -536,6 +544,13 @@ export const NewRuleImplementation = ({
     clone || !edition
       ? createRuleImplementation({
           rule_implementation,
+          redirectUrl: conceptId
+            ? linkTo.CONCEPT_LINKS_IMPLEMENTATIONS({
+                business_concept_id: conceptId,
+                id: conceptVersionId,
+              })
+            : null,
+          conceptId,
         })
       : updateRuleImplementation({
           rule_implementation: {
@@ -569,6 +584,8 @@ export const NewRuleImplementation = ({
             <RuleImplementationRawForm
               mode={clone ? "clone" : edition ? "edition" : ""}
               implementationKey={ruleImplementation.implementationKey}
+              conceptDomainId={conceptDomainId}
+              domainIds={conceptDomainIds}
               rawContent={ruleImplementation.rawContent}
               setImplementationKey={setImplementationKey}
               setImplementationRawContent={setImplementationRawContent}
@@ -581,6 +598,8 @@ export const NewRuleImplementation = ({
               addPopulation={addPopulation}
               addValidation={addValidation}
               addSegment={addSegment}
+              conceptDomainId={conceptDomainId}
+              domainIds={conceptDomainIds}
               onSubmit={doSubmit}
               onChange={onChange}
               operators={operators}
@@ -604,6 +623,8 @@ export const NewRuleImplementation = ({
 };
 
 NewRuleImplementation.propTypes = {
+  conceptId: PropTypes.number,
+  conceptVersionId: PropTypes.number,
   clone: PropTypes.bool,
   createRuleImplementation: PropTypes.func.isRequired,
   edition: PropTypes.bool,
@@ -613,6 +634,8 @@ NewRuleImplementation.propTypes = {
   structuresFields: PropTypes.object,
   structuresSiblings: PropTypes.object,
   updateRuleImplementation: PropTypes.func,
+  conceptDomainId: PropTypes.number,
+  conceptDomainIds: PropTypes.array,
 };
 
 const mapStateToProps = (state) => ({
@@ -626,13 +649,54 @@ const mapStateToProps = (state) => ({
   structuresSiblings: state.structuresSiblings,
 });
 
-export const ImplementationLoader = (props) => {
+export const ImplementationOperatorLoader = (props) => {
   const { data, error, loading } = useOperators();
   if (error) return null;
   if (loading) return <Loading />;
   return <NewRuleImplementation operators={data} {...props} />;
 };
 
+export const ImplementationConceptLoader = (props) => {
+  const conceptId = props.conceptId;
+  const conceptVersionId = props.conceptVersionId;
+
+  const { concept, error, loading } = useConcept(conceptId, conceptVersionId);
+  // TODO: if error??;
+  const domainId = concept?.data?.domain?.id;
+  const sharedTo = concept?.data?._embedded?.shared_to;
+
+  const conceptDomainIds = _.flow(
+    _.map(({ id: id }) => id),
+    _.concat(domainId)
+  )(sharedTo);
+
+  return loading ? (
+    <Loader />
+  ) : (
+    <ImplementationOperatorLoader
+      {...props}
+      conceptDomainId={domainId}
+      conceptDomainIds={conceptDomainIds}
+      conceptId={conceptId}
+      conceptVersionId={conceptVersionId}
+    />
+  );
+};
+
+export const ImplementationLoader = (props) => {
+  const { search } = useLocation();
+  const { business_concept_id, id } = queryString.parse(search);
+  return id && business_concept_id ? (
+    <ImplementationConceptLoader
+      {...props}
+      conceptId={business_concept_id}
+      conceptVersionId={id}
+    />
+  ) : (
+    <ImplementationOperatorLoader {...props} />
+  );
+};
+
 export default connect(mapStateToProps, {
   createRuleImplementation,
   updateRuleImplementation,

package/src/components/RuleImplementation.js

@@ -1,16 +1,14 @@
 import _ from "lodash/fp";
 import React from "react";
 import PropTypes from "prop-types";
-import { useIntl } from "react-intl";
 import { connect } from "react-redux";
-import { Header, Label, Grid, Icon } from "semantic-ui-react";
+import { Header, Grid, Icon } from "semantic-ui-react";
 import ImplementationActions from "./ImplementationActions";
 import ImplementationResultBar from "./ImplementationResultBar";
 import RuleImplementationTabs from "./RuleImplementationTabs";
 import Subscription from "./Subscription";
 
 export const RuleImplementation = ({ children, ruleImplementation }) => {
-  const { formatMessage } = useIntl();
   const deletedAt = _.prop("deleted_at")(ruleImplementation);
 
   return (

package/src/components/ruleImplementationForm/InformationForm.js

@@ -27,6 +27,8 @@ export const InformationForm = ({
   ruleImplementation,
   setIsValid,
   onDomainsLoad,
+  conceptDomainId,
+  domainIds,
 }) => {
   const { formatMessage } = useIntl();
 
@@ -35,7 +37,7 @@ export const InformationForm = ({
 
     setIsValid(_.isEmpty(valid));
   };
-  const domainId = ruleImplementation?.domain_id;
+  const domainId = conceptDomainId || ruleImplementation?.domain_id;
   const domainActions = ["publishImplementation", "manageSegments"];
 
   return (
@@ -82,12 +84,13 @@ export const InformationForm = ({
           </label>
           <DomainSelector
             action={
-              ruleImplementation.rule_id
-                ? "manageImplementations"
+              conceptDomainId
+                ? "manageLinkedImplementations"
                 : "manageRulelessImplementations"
             }
-            value={ruleImplementation.domain_id}
+            value={domainId}
             domainActions={domainActions}
+            domainIds={domainIds}
             onLoad={(data) => onDomainsLoad(data.domains)}
             onChange={(_e, { value }) => onChange("domain_id", value)}
             labels
@@ -120,6 +123,8 @@ InformationForm.propTypes = {
   setImplementationKey: PropTypes.func,
   setIsValid: PropTypes.func,
   onDomainsLoad: PropTypes.func,
+  conceptDomainId: PropTypes.array,
+  domainIds: PropTypes.array,
 };
 
 export default InformationForm;

package/src/components/ruleImplementationForm/RuleImplementationForm.js

@@ -41,12 +41,15 @@ RuleImplementationStep.propTypes = {
   activeStep: PropTypes.string,
   name: PropTypes.string,
   icon: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
+  disabled: PropTypes.bool,
 };
 
 export const RuleImplementationForm = ({
   addPopulation,
   addSegment,
   addValidation,
+  conceptDomainId,
+  domainIds,
   isSubmitting,
   onChange,
   onSubmit,
@@ -342,6 +345,8 @@ export const RuleImplementationForm = ({
                   onChange,
                   ruleImplementation,
                   setImplementationKey,
+                  conceptDomainId,
+                  domainIds,
                   setIsValid: setContentIsValid,
                   onDomainsLoad: (domains) => {
                     setDomains(domains);
@@ -505,6 +510,8 @@ RuleImplementationForm.propTypes = {
   addValidation: PropTypes.func,
   addSegment: PropTypes.func,
   authManageSegments: PropTypes.bool,
+  conceptDomainId: PropTypes.number,
+  domainIds: PropTypes.array,
   isAdmin: PropTypes.bool,
   isSubmitting: PropTypes.bool,
   onChange: PropTypes.func,
@@ -519,9 +526,7 @@ RuleImplementationForm.propTypes = {
 };
 
 const mapStateToProps = ({ ruleImplementationCreating }) => {
-  return {
-    isSubmitting: ruleImplementationCreating,
-  };
+  return { isSubmitting: ruleImplementationCreating };
 };
 
 export default connect(mapStateToProps)(RuleImplementationForm);

package/src/components/ruleImplementationForm/RuleImplementationRawForm.js

@@ -2,7 +2,7 @@ import _ from "lodash/fp";
 import React, { useState, useEffect } from "react";
 import PropTypes from "prop-types";
 import { connect } from "react-redux";
-import { useHistory } from "react-router-dom";
+import { useHistory, useLocation } from "react-router-dom";
 import { FormattedMessage, useIntl } from "react-intl";
 import { gql, useQuery } from "@apollo/client";
 import { Loading } from "@truedat/core/components";
@@ -26,6 +26,12 @@ const DomainActionsLoader = ({ id, actions, onLoad }) => {
   return null;
 };
 
+DomainActionsLoader.propTypes = {
+  id: PropTypes.number,
+  actions: PropTypes.array,
+  onLoad: PropTypes.func,
+};
+
 const Help = ({ message }) => {
   const { formatMessage } = useIntl();
   return (
@@ -45,6 +51,8 @@ Help.propTypes = {
 };
 
 export const RuleImplementationRawForm = ({
+  conceptDomainId,
+  domainIds,
   implementationKey,
   isSubmitting,
   onChange,
@@ -57,9 +65,11 @@ export const RuleImplementationRawForm = ({
   sources,
   sourcesLoading,
 }) => {
-  const domainActions = ["publishImplementation"];
   const { formatMessage } = useIntl();
   const history = useHistory();
+
+  const domainActions = ["publishImplementation"];
+
   const [isContentValid, setIsContentValid] = useState();
 
   const [domains, setDomains] = useState();
@@ -172,7 +182,8 @@ export const RuleImplementationRawForm = ({
 
   const doCancel = () => history.goBack();
   const errors = getErrors();
-  const domainId = ruleImplementation?.domain_id || rule?.domain_id;
+  const domainId =
+    conceptDomainId || ruleImplementation?.domain_id || rule?.domain_id;
   return (
     <Form className="rule">
       <Form.Radio
@@ -202,12 +213,13 @@ export const RuleImplementationRawForm = ({
         <Form.Field>
           <DomainSelector
             action={
-              ruleImplementation.rule_id
-                ? "manageRawImplementations"
+              conceptDomainId
+                ? "manageLinkedRawImplementations"
                 : "manageRawRulelessImplementations"
             }
-            value={ruleImplementation.domain_id}
+            value={domainId}
             domainActions={domainActions}
+            domainIds={domainIds}
             onLoad={(data) => setDomains(data.domains)}
             onChange={(_e, { value }) => onChange("domain_id", value)}
             labels
@@ -371,6 +383,8 @@ export const RuleImplementationRawForm = ({
 };
 
 RuleImplementationRawForm.propTypes = {
+  conceptDomainId: PropTypes.number,
+  domainIds: PropTypes.array,
   implementationKey: PropTypes.string,
   isSubmitting: PropTypes.bool,
   onChange: PropTypes.func,

package/src/hooks/index.js

@@ -0,0 +1 @@
+export * from "./useConcept";

package/src/hooks/useConcept.js

@@ -0,0 +1,13 @@
+import { compile } from "path-to-regexp";
+import useSWR from "swr";
+import { API_BUSINESS_CONCEPT_VERSION } from "@truedat/bg/concepts/api";
+import { apiJson } from "@truedat/core/services/api";
+
+const toApiPath = compile(API_BUSINESS_CONCEPT_VERSION);
+
+export const useConcept = (business_concept_id, id) => {
+  const url = toApiPath({ business_concept_id, id });
+  const { data, error } = useSWR(url, apiJson);
+  const concept = data?.data;
+  return { concept, error, loading: !error && !data };
+};

package/src/messages/en.js

@@ -3,6 +3,7 @@ export default {
   "alert.createExecutionGroup.success.content":
     "{count} implementations queued for execution",
   "alert.createExecutionGroup.success.header": "Executions scheduled",
+  "alert.createImplementationConcept.failed.header": "Error linking to concept",
   "alert.createImplementationStructure.failed.header":
     "Error linking to structure",
   "alert.createRule.failed.header": "Error creating rule",
@@ -15,6 +16,7 @@ export default {
   "alert.updateRuleImplementation.failed.header":
     "Error updating implementation",
   "concepts.rules.empty": "This concept has no quality rules",
+  "concepts.implementations.empty": "This concept has no implementations",
   "createImplementationStructure.error.implementation_id.has already been taken":
     "A link with same structure and type already exists",
   "createRule.error.domain_id.required": "Domain is required",

package/src/messages/es.js

@@ -3,6 +3,7 @@ export default {
   "alert.createExecutionGroup.success.content":
     "Se ha solicitado la ejecución de {count} implementaciones",
   "alert.createExecutionGroup.success.header": "Ejecuciones programadas",
+  "alert.createImplementationConcept.failed.header": "Error al vincular con el concepto",
   "alert.createImplementationStructure.failed.header":
     "Error al vincular con estructura",
   "alert.createRule.failed.header": "Error creando regla",
@@ -15,6 +16,7 @@ export default {
   "alert.updateRuleImplementation.failed.header":
     "Error actualizando implementación",
   "concepts.rules.empty": "Ese concepto no tiene reglas de calidad",
+  "concepts.implementations.empty": "Ese concepto no tiene implementaciones",
   "createImplementationStructure.error.implementation_id.has already been taken":
     "Una relación con misma estructura y tipo ya existe",
   "createRule.error.domain_id.required": "Dominio es requerido",

package/src/reducers/dqMessage.js

@@ -1,6 +1,7 @@
 import _ from "lodash/fp";
 import { dismissAlert } from "@truedat/core/routines";
 import {
+  createRuleImplementation,
   uploadRules,
   uploadImplementations,
   uploadResults,
@@ -14,6 +15,17 @@ const dqMessage = (state = initialState, { type, payload }) => {
   switch (type) {
     case dismissAlert.TRIGGER:
       return initialState;
+    case createRuleImplementation.FAILURE:
+      if (payload.status != 500 && payload.message) {
+        return {
+          error: true,
+          header: "alert.createImplementationConcept.failed.header",
+          icon: "attention",
+          text: "",
+        };
+      } else {
+        return null;
+      }
     case uploadRules.SUCCESS:
       const messages = _.has("errors")(payload.data)
         ? _.flow(

package/src/reducers/ruleImplementationRedirect.js

@@ -26,10 +26,19 @@ export const ruleImplementationRedirect = (
       return initialState;
     case createRuleImplementation.SUCCESS: {
       const id = payload?.data?.id;
-      return id
+      return payload?.redirectUrl
+        ? payload.redirectUrl
+        : id
         ? linkTo.IMPLEMENTATION({ implementation_id: id })
         : linkTo.IMPLEMENTATIONS();
     }
+    case createRuleImplementation.FAILURE: {
+      return payload?.implementation_id
+        ? linkTo.IMPLEMENTATION_CONCEPT_LINKS({
+            implementation_id: payload?.implementation_id,
+          })
+        : state;
+    }
     case createImplementationStructure.SUCCESS: {
       return payload?.redirectUrl;
     }

package/src/sagas/__tests__/createRuleImplementation.spec.js

@@ -1,5 +1,6 @@
 import { testSaga } from "redux-saga-test-plan";
 import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import { API_RELATIONS } from "@truedat/lm/api";
 import {
   createRuleImplementationRequestSaga,
   createRuleImplementationSaga,
@@ -53,8 +54,20 @@ describe("sagas: createRuleImplementationSaga", () => {
     ],
     rule_id: 1,
   };
+
+  const relation = {
+    context: {},
+    source_id: 2,
+    source_type: "implementation_ref",
+    target_id: 1,
+    target_type: "business_concept",
+    tag_ids: [],
+  };
+
   const data = { rule_implementation };
+  const relationData = { relation };
   const url = API_RULE_IMPLEMENTATIONS;
+  const relationsUrl = API_RELATIONS;
   const payload = { rule_implementation };
 
   it("should encode request content and put a success action when a response is returned", () => {
@@ -67,7 +80,7 @@ describe("sagas: createRuleImplementationSaga", () => {
         .next(rule_implementation)
         .call(apiJsonPost, url, data, JSON_OPTS)
         .next({ data })
-        .put(createRuleImplementation.success(data))
+        .put(createRuleImplementation.success({ data, redirectUrl: undefined }))
         .next()
         .put(clearStructure.trigger())
         .next()
@@ -97,4 +110,29 @@ describe("sagas: createRuleImplementationSaga", () => {
         .isDone();
     }).not.toThrow();
   });
+
+  it("should encode request and call relation if have conceptId and redirectUrl", () => {
+    const redirectUrl = "/concepts/1/versions/2/links/implementations";
+    const payload = { rule_implementation, conceptId: 1, redirectUrl };
+
+    expect(() => {
+      testSaga(createRuleImplementationSaga, { payload })
+        .next()
+        .put(createRuleImplementation.request())
+        .next()
+        .call(encodeRawContent, rule_implementation)
+        .next(rule_implementation)
+        .call(apiJsonPost, url, data, JSON_OPTS)
+        .next({ data })
+        // .call(apiJsonPost, relationsUrl, relationData, JSON_OPTS)
+        .next()
+        .put(createRuleImplementation.success({ data, redirectUrl }))
+        .next()
+        .put(clearStructure.trigger())
+        .next()
+        .put(createRuleImplementation.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
 });

package/src/sagas/createRuleImplementation.js

@@ -1,23 +1,51 @@
+import _ from "lodash/fp";
 import { call, put, takeLatest } from "redux-saga/effects";
 import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import { API_RELATIONS } from "@truedat/lm/api";
 import { createRuleImplementation, clearStructure } from "../routines";
 import { API_RULE_IMPLEMENTATIONS } from "../api";
 import { encodeRawContent } from "../services/encodeRawContent";
 
 export function* createRuleImplementationSaga({ payload }) {
   try {
-    const { rule_implementation } = payload;
+    const { rule_implementation, redirectUrl, conceptId } = payload;
     const url = API_RULE_IMPLEMENTATIONS;
     yield put(createRuleImplementation.request());
     const encoded = yield call(encodeRawContent, rule_implementation);
     const requestData = { rule_implementation: encoded };
     const { data } = yield call(apiJsonPost, url, requestData, JSON_OPTS);
-    yield put(createRuleImplementation.success(data));
+    if (conceptId && redirectUrl) {
+      const relationsUrl = API_RELATIONS;
+      const relation = {
+        context: {},
+        source_id: data?.data?.implementation_ref,
+        source_type: "implementation_ref",
+        target_id: conceptId,
+        target_type: "business_concept",
+        tag_ids: [],
+      };
+      const relationData = { relation };
+      yield call(apiJsonPost, relationsUrl, relationData, JSON_OPTS);
+    }
+    yield put(createRuleImplementation.success({ data, redirectUrl }));
     yield put(clearStructure.trigger());
   } catch (error) {
     if (error.response) {
       const { status, data } = error.response;
-      yield put(createRuleImplementation.failure({ status, data }));
+      const responseURL = error.response?.request?.responseURL;
+      if (_.includes("/api/relations")(responseURL)) {
+        const { relation } = JSON.parse(error.config.data);
+        yield put(
+          createRuleImplementation.failure({
+            status,
+            data,
+            message: "ruleImplementation.linkConcept.failed",
+            implementation_id: relation.source_id,
+          })
+        );
+      } else {
+        yield put(createRuleImplementation.failure({ status, data }));
+      }
     } else {
       yield put(createRuleImplementation.failure(error.message));
     }