@truedat/dq 4.44.2 → 4.44.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [4.44.3] 2022-05-11
+
+### Added
+
+- [TD-4045] Implementation execution button in implementation view
+
 ## [4.44.2] 2022-05-11
 
 ### Fixed
@@ -16,7 +22,8 @@
 
 # Added
 
-- [TD-4538] Add more coding for segments configuration and segment results for implementations
+- [TD-4538] Add more coding for segments configuration and segment results for
+  implementations
 
 ## [4.43.3] 2022-05-04
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.44.2",
+  "version": "4.44.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.44.2",
+    "@truedat/test": "4.44.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.44.2",
-    "@truedat/df": "4.44.2",
+    "@truedat/core": "4.44.3",
+    "@truedat/df": "4.44.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": "ca0c5fffcba96736f7a2054f3c37789da8c30a9e"
+  "gitHead": "d5e72d523389c6e66d6f7168d7e3546b5d2ffdda"
 }

package/src/components/EditRule.js

@@ -15,7 +15,7 @@ export const EditRule = ({ rule, updateRule }) =>
           <FormattedMessage id="quality.actions.edit" />
         </Header.Content>
       </Header>
-      <RuleForm handleSubmit={updateRule} rule={rule} editMode />
+      <RuleForm onSubmit={updateRule} rule={rule} editMode />
     </Container>
   );
 

package/src/components/ExecutionForm.js

@@ -1,48 +1,35 @@
 import _ from "lodash/fp";
-import React, { Suspense, useState } from "react";
+import React, { useState } from "react";
+import { Button, Form, Header } from "semantic-ui-react";
 import PropTypes from "prop-types";
-import { connect } from "react-redux";
 import { useIntl } from "react-intl";
-import { Button, Form, Header } from "semantic-ui-react";
+import { TemplateSelector } from "@truedat/core/components";
 import { validateContent } from "@truedat/df/utils";
-import { selectTemplate } from "@truedat/df/routines";
-
-const TemplateSelector = React.lazy(() =>
-  import("@truedat/df/templates/components/TemplateSelector")
-);
-
-const TemplateLoader = React.lazy(() =>
-  import("@truedat/df/templates/components/TemplateLoader")
-);
 
 const DynamicForm = React.lazy(() =>
   import("@truedat/df/components/DynamicForm")
 );
 
-export const ExecutionForm = ({
-  count,
-  selectTemplate,
-  template,
-  templates,
-  handleSubmit,
-  onCancel,
-}) => {
+export const ExecutionForm = ({ count, onSubmit, onCancel }) => {
   const { formatMessage } = useIntl();
   const [content, setContent] = useState({});
+  const [template, setTemplate] = useState();
+  const [templatesLoading, setTemplatesLoading] = useState(true);
 
   const handleContentChange = (content) => setContent(content);
 
-  const handleTemplateSelected = (e, { value }) =>
-    selectTemplate({ id: value });
+  const handleTemplatesLoaded = ({ templates }) => {
+    setTemplatesLoading(false);
+    if (templates?.length === 1) {
+      setTemplate(templates[0]);
+    }
+  };
+
+  const handleTemplateSelected = (e, { template }) => setTemplate(template);
 
   const isInvalid = () =>
     template && !_.isEmpty(validateContent(template)(content));
 
-  if (_.size(templates) == 1) {
-    const id = _.flow(_.head, _.prop("id"))(templates);
-    selectTemplate({ id });
-  }
-
   return (
     <>
       <Header
@@ -51,66 +38,69 @@ export const ExecutionForm = ({
           id: "implementations.actions.execution.confirmation.header",
         })}
       />
-      <Suspense fallback={null}>
-        <Form>
-          <TemplateLoader scope="qe" />
-          {_.size(templates) > 1 && (
-            <TemplateSelector
-              name="template"
-              selectedValue={_.prop("id")(template)}
-              onChange={handleTemplateSelected}
-              isOptional={true}
+      <Form loading={templatesLoading}>
+        <TemplateSelector
+          scope="qe"
+          selectedValue={template?.id}
+          onChange={handleTemplateSelected}
+          onLoad={handleTemplatesLoaded}
+          clearable
+        />
+        {template?.id ? (
+          <>
+            <Header
+              as="h3"
+              content={formatMessage({
+                id: "implementations.actions.execution.confirmation.legend",
+              })}
             />
-          )}
-          {template && template.id && (
-            <>
-              <Header
-                as="h3"
-                content={formatMessage({
-                  id: "implementations.actions.execution.confirmation.legend",
-                })}
+            <div
+              style={{
+                maxHeight: "calc(100vh - 550px)",
+                overflowY: "auto",
+              }}
+            >
+              <DynamicForm
+                onChange={handleContentChange}
+                content={content}
+                template={template}
               />
-              <div
-                style={{ maxHeight: "calc(100vh - 550px)", overflowY: "auto" }}
-              >
-                <DynamicForm onChange={handleContentChange} content={content} />
-              </div>
-            </>
+            </div>
+          </>
+        ) : null}
+        <p>
+          {formatMessage(
+            {
+              id:
+                count === 1
+                  ? "implementation.actions.execution.confirmation.content"
+                  : "implementations.actions.execution.confirmation.content",
+            },
+            { implementations_count: count }
           )}
-          <p>
-            {formatMessage(
-              { id: "implementations.actions.execution.confirmation.content" },
-              { implementations_count: count }
-            )}
-          </p>
-          <div className="actions">
-            <Button
-              secondary
-              onClick={onCancel}
-              content={formatMessage({ id: "actions.cancel" })}
-            />
-            <Button
-              primary
-              disabled={isInvalid()}
-              onClick={() => handleSubmit(content)}
-              content={formatMessage({ id: "actions.create" })}
-            />
-          </div>
-        </Form>
-      </Suspense>
+        </p>
+        <div className="actions">
+          <Button
+            secondary
+            onClick={onCancel}
+            content={formatMessage({ id: "actions.cancel" })}
+          />
+          <Button
+            primary
+            disabled={isInvalid()}
+            onClick={() => onSubmit(content)}
+            content={formatMessage({ id: "actions.create" })}
+          />
+        </div>
+      </Form>
     </>
   );
 };
 
 ExecutionForm.propTypes = {
   count: PropTypes.number,
-  template: PropTypes.object,
-  templates: PropTypes.array,
-  selectTemplate: PropTypes.func,
-  handleSubmit: PropTypes.func,
+  onSubmit: PropTypes.func,
   onCancel: PropTypes.func,
 };
 
-const mapStateToProps = _.pick(["templates", "template"]);
-
-export default connect(mapStateToProps, { selectTemplate })(ExecutionForm);
+export default ExecutionForm;

package/src/components/ExecutionPopup.js

@@ -1,4 +1,3 @@
-import _ from "lodash/fp";
 import React, { useState } from "react";
 import PropTypes from "prop-types";
 import { connect } from "react-redux";
@@ -10,7 +9,7 @@ export const ExecutionPopup = ({
   disabled,
   executionGroupLoading,
   count,
-  handleSubmit,
+  onSubmit,
 }) => {
   const { formatMessage } = useIntl();
   const [open, setOpen] = useState(false);
@@ -32,14 +31,17 @@ export const ExecutionPopup = ({
           disabled={disabled}
           loading={executionGroupLoading}
           content={formatMessage({
-            id: "implementations.actions.do_execution",
+            id:
+              count === 1
+                ? "implementation.actions.do_execution"
+                : "implementations.actions.do_execution",
           })}
         />
       }
     >
       <ExecutionForm
         count={count}
-        handleSubmit={handleSubmit}
+        onSubmit={onSubmit}
         onCancel={() => setOpen(false)}
       />
     </Popup>
@@ -50,9 +52,11 @@ ExecutionPopup.propTypes = {
   count: PropTypes.number,
   disabled: PropTypes.bool,
   executionGroupLoading: PropTypes.bool,
-  handleSubmit: PropTypes.func,
+  onSubmit: PropTypes.func,
 };
 
-const mapStateToProps = _.pick(["executionGroupLoading"]);
+const mapStateToProps = ({ executionGroupLoading }) => ({
+  executionGroupLoading,
+});
 
 export default connect(mapStateToProps)(ExecutionPopup);

package/src/components/NewRule.js

@@ -21,7 +21,7 @@ export const NewRule = ({ rule, createRule }) => (
       </Header.Content>
     </Header>
     <DomainsLoader actions="manage_quality_rule" />
-    <RuleForm handleSubmit={createRule} />
+    <RuleForm onSubmit={createRule} />
   </Container>
 );
 

package/src/components/NewRuleImplementation.js

@@ -17,10 +17,6 @@ import RuleImplementationForm from "./ruleImplementationForm/RuleImplementationF
 import RuleImplementationRawForm from "./ruleImplementationForm/RuleImplementationRawForm";
 import ImplementationSummary from "./ImplementationSummary";
 
-const TemplateLoader = React.lazy(() =>
-  import("@truedat/df/templates/components/TemplateLoader")
-);
-
 const updateDatasetKey = (data) =>
   _.reduce.convert({ cap: false })(
     (acc, value, key) =>
@@ -248,8 +244,6 @@ export const NewRuleImplementation = ({
   structuresFields,
   structuresSiblings,
   operators,
-  template,
-  applyTemplate,
   implementationType = "",
 }) => {
   const precalculatedDataset = _.flow(
@@ -257,17 +251,16 @@ export const NewRuleImplementation = ({
     withDefaultAlias
   )(ruleImplementationProps);
 
+  const [template, setTemplate] = useState(null);
   const [ruleImplementation, setRuleImplementation] = useState(
     edition
       ? {
-          id: clone ? null : _.prop("id")(ruleImplementationProps),
+          id: clone ? null : ruleImplementationProps.id,
           executable: ruleImplementationProps.executable,
           implementationKey: clone
             ? ""
-            : _.prop("implementation_key")(ruleImplementationProps),
-          implementationType: _.prop("implementation_type")(
-            ruleImplementationProps
-          ),
+            : ruleImplementationProps.implementation_key,
+          implementationType: ruleImplementationProps.implementation_type,
           dataset: precalculatedDataset,
           populations: _.flow(
             _.pathOr([], "populations"),
@@ -308,10 +301,8 @@ export const NewRuleImplementation = ({
             precalculatedDataset
           ),
 
-          rawContent: {
-            ..._.prop("raw_content")(ruleImplementationProps),
-          },
-          dfName: _.prop("df_name")(ruleImplementationProps),
+          rawContent: ruleImplementationProps.raw_content,
+          dfName: ruleImplementationProps.df_name,
           dfContent: ruleImplementationProps.df_content,
           result_type: ruleImplementationProps.result_type,
           minimum: ruleImplementationProps.minimum,
@@ -378,17 +369,13 @@ export const NewRuleImplementation = ({
       _.map(_.prop("data_structure_id"))
     )(structuresFields);
 
-    const belongsToDataset = (structureId) => {
-      return _.includes(structureId)(all_fields);
-    };
+    const belongsToDataset = (structureId) =>
+      _.includes(structureId)(all_fields);
 
-    const valueInDataset = (val) => {
-      return (
-        _.pathEq("operator.value_type_filter", "any")(val) ||
-        _.isNil(_.path("value[0].id")(val)) ||
-        belongsToDataset(_.path("value[0].id")(val))
-      );
-    };
+    const valueInDataset = (val) =>
+      _.pathEq("operator.value_type_filter", "any")(val) ||
+      _.isNil(_.path("value[0].id")(val)) ||
+      belongsToDataset(_.path("value[0].id")(val));
 
     const validations_within_dataset = _.flow(
       _.prop("validations"),
@@ -466,27 +453,26 @@ export const NewRuleImplementation = ({
     setRuleImplementation({ ...ruleImplementation, rawContent });
 
   useEffect(() => {
-    if (!_.isEmpty(template)) {
-      onChange("dfContent", applyTemplate(ruleImplementation.dfContent));
+    if (template) {
+      onChange(
+        "dfContent",
+        applyTemplate(template)(ruleImplementation.dfContent)
+      );
     }
     /* eslint-disable react-hooks/exhaustive-deps */
   }, [template]);
 
   const doSubmit = () => {
-    const populations = _.filter(_.negate(_.isEmpty))(
-      ruleImplementation.populations
-    );
-    const validations = _.filter(_.negate(_.isEmpty))(
-      ruleImplementation.validations
-    );
-    const segments = _.filter(_.negate(_.isEmpty))(ruleImplementation.segments);
+    const populations = _.reject(_.isEmpty)(ruleImplementation.populations);
+    const validations = _.reject(_.isEmpty)(ruleImplementation.validations);
+    const segments = _.reject(_.isEmpty)(ruleImplementation.segments);
 
     const dfContent = _.flow(
       _.prop("dfContent"),
-      applyTemplate
+      applyTemplate(template)
     )(ruleImplementation);
 
-    const df_name = _.getOr(null, "name")(template);
+    const df_name = template?.name || ruleImplementation?.dfName || null;
 
     const raw_content = _.prop("rawContent")(ruleImplementation);
     const source_id = _.prop("source_id")(raw_content);
@@ -496,9 +482,8 @@ export const NewRuleImplementation = ({
       ruleImplementation.implementationType == "raw"
         ? {
             executable: ruleImplementation.executable,
-            implementation_key: _.prop("implementationKey")(ruleImplementation),
-            implementation_type:
-              _.prop("implementationType")(ruleImplementation),
+            implementation_key: ruleImplementation.implementationKey,
+            implementation_type: ruleImplementation.implementationType,
             df_name,
             df_content: dfContent,
             rule_id: rule ? rule.id : ruleImplementation.rule_id,
@@ -510,13 +495,12 @@ export const NewRuleImplementation = ({
           }
         : {
             executable: ruleImplementation.executable,
-            dataset: datasetAttributes(_.prop("dataset")(ruleImplementation)),
+            dataset: datasetAttributes(ruleImplementation.dataset),
             populations: populationsAttributes(populations),
             validations: conditionAttributes(validations),
             segments,
-            implementation_key: _.prop("implementationKey")(ruleImplementation),
-            implementation_type:
-              _.prop("implementationType")(ruleImplementation),
+            implementation_key: ruleImplementation.implementationKey,
+            implementation_type: ruleImplementation.implementationType,
             df_name,
             df_content: dfContent,
             rule_id: rule ? rule.id : ruleImplementation.rule_id,
@@ -539,84 +523,81 @@ export const NewRuleImplementation = ({
   };
 
   return (
-    <>
-      <TemplateLoader />
-      <Grid divided className="full-height">
-        <Grid.Column width="11">
-          <Grid.Row>
-            <Header as="h2">
-              <Header.Content>
-                <FormattedMessage
-                  id={
-                    clone
-                      ? "ruleImplementations.actions.create"
-                      : edition
-                      ? "ruleImplementations.actions.edit"
-                      : "ruleImplementations.actions.create"
-                  }
-                />
-              </Header.Content>
-            </Header>
-            <Divider hidden />
-          </Grid.Row>
-          <Grid.Row stretched>
-            {ruleImplementation.implementationType == "raw" ? (
-              <RuleImplementationRawForm
-                mode={clone ? "clone" : edition ? "edition" : ""}
-                implementationKey={_.prop("implementationKey")(
-                  ruleImplementation
-                )}
-                rawContent={_.prop("rawContent")(ruleImplementation)}
-                setImplementationKey={setImplementationKey}
-                setImplementationRawContent={setImplementationRawContent}
-                ruleImplementation={ruleImplementation}
-                onChange={onChange}
-                handleSubmit={doSubmit}
-                sources={sources}
-                sourcesLoading={sourcesLoading}
-              />
-            ) : (
-              <RuleImplementationForm
-                ruleImplementation={ruleImplementation}
-                setStructures={setDataset}
-                addPopulation={addPopulation}
-                setPopulations={setPopulations}
-                setValidations={setValidations}
-                addSegments={addSegments}
-                setSegments={setSegments}
-                operators={operators}
-                setImplementationKey={setImplementationKey}
-                onChange={onChange}
-                handleSubmit={doSubmit}
+    <Grid divided className="full-height">
+      <Grid.Column width="11">
+        <Grid.Row>
+          <Header as="h2">
+            <Header.Content>
+              <FormattedMessage
+                id={
+                  clone
+                    ? "ruleImplementations.actions.create"
+                    : edition
+                    ? "ruleImplementations.actions.edit"
+                    : "ruleImplementations.actions.create"
+                }
               />
-            )}
-          </Grid.Row>
-        </Grid.Column>
-        <Grid.Column width="5">
-          {ruleImplementation.implementationType != "raw" && (
-            <ImplementationSummary ruleImplementation={ruleImplementation} />
+            </Header.Content>
+          </Header>
+          <Divider hidden />
+        </Grid.Row>
+        <Grid.Row stretched>
+          {ruleImplementation.implementationType == "raw" ? (
+            <RuleImplementationRawForm
+              mode={clone ? "clone" : edition ? "edition" : ""}
+              implementationKey={ruleImplementation.implementationKey}
+              rawContent={ruleImplementation.rawContent}
+              setImplementationKey={setImplementationKey}
+              setImplementationRawContent={setImplementationRawContent}
+              ruleImplementation={ruleImplementation}
+              onChange={onChange}
+              onSubmit={doSubmit}
+              sources={sources}
+              sourcesLoading={sourcesLoading}
+              template={template}
+              setTemplate={setTemplate}
+            />
+          ) : (
+            <RuleImplementationForm
+              addPopulation={addPopulation}
+              addSegments={addSegments}
+              onSubmit={doSubmit}
+              onChange={onChange}
+              operators={operators}
+              ruleImplementation={ruleImplementation}
+              setImplementationKey={setImplementationKey}
+              setPopulations={setPopulations}
+              setSegments={setSegments}
+              setStructures={setDataset}
+              setTemplate={setTemplate}
+              setValidations={setValidations}
+              template={template}
+            />
           )}
-        </Grid.Column>
-      </Grid>
-    </>
+        </Grid.Row>
+      </Grid.Column>
+      <Grid.Column width="5">
+        {ruleImplementation.implementationType === "raw" ? null : (
+          <ImplementationSummary ruleImplementation={ruleImplementation} />
+        )}
+      </Grid.Column>
+    </Grid>
   );
 };
 
 NewRuleImplementation.propTypes = {
   clone: PropTypes.bool,
   createRuleImplementation: PropTypes.func.isRequired,
-  updateRuleImplementation: PropTypes.func,
   edition: PropTypes.bool,
+  implementationType: PropTypes.string,
+  operators: PropTypes.object,
   rule: PropTypes.object,
   ruleImplementationProps: PropTypes.object,
-  structuresFields: PropTypes.object,
-  structuresSiblings: PropTypes.object,
-  operators: PropTypes.object,
-  template: PropTypes.object,
-  applyTemplate: PropTypes.func,
   sources: PropTypes.array,
   sourcesLoading: PropTypes.bool,
-  implementationType: PropTypes.string,
+  structuresFields: PropTypes.object,
+  structuresSiblings: PropTypes.object,
+  updateRuleImplementation: PropTypes.func,
 };
 
 export const SOURCES_WITH_CONFIG = gql`
@@ -630,9 +611,10 @@ export const SOURCES_WITH_CONFIG = gql`
 `;
 
 export const NewRuleImplementationLoader = (props) => {
-  const { data, loading } = useQuery(SOURCES_WITH_CONFIG, {
+  const { data, error, loading } = useQuery(SOURCES_WITH_CONFIG, {
     variables: { jobTypes: "quality" },
   });
+  if (error) return null;
   if (loading) return <Loading />;
   const sources = data?.sources || [];
   return (
@@ -654,8 +636,6 @@ const mapStateToProps = (state) => ({
   structuresFields: state.structuresFields,
   structuresSiblings: state.structuresSiblings,
   operators: getRuleImplementationOperators(state),
-  template: _.defaultTo({})(state.template),
-  applyTemplate: applyTemplate(state.template),
 });
 
 export default connect(mapStateToProps, {