@truedat/dq 4.42.5 → 4.43.1

package/src/components/NewRuleImplementation.js

@@ -224,8 +224,8 @@ const updateStructureParentIndex = (structures) => (structure) => {
   return structure;
 };
 
-const withConditionDefaultAlias = (conditions, structures) =>
-  _.map((p) => {
+const withConditionDefaultAlias = (conditions, structures) => {
+  return _.map((p) => {
     return {
       ...p,
       structure: updateStructureParentIndex(structures)(p.structure),
@@ -235,6 +235,7 @@ const withConditionDefaultAlias = (conditions, structures) =>
           : p.value,
     };
   })(conditions);
+};
 
 export const NewRuleImplementation = ({
   canManageRaw,
@@ -296,6 +297,18 @@ export const NewRuleImplementation = ({
             ),
             precalculatedDataset
           ),
+          segments: withConditionDefaultAlias(
+            addFieldType(
+              ruleImplementationProps,
+              structuresFields,
+              structuresSiblings,
+              "segments",
+              "segment",
+              { name: "" }
+            ),
+            precalculatedDataset
+          ),
+
           rawContent: {
             ..._.prop("raw_content")(ruleImplementationProps),
           },
@@ -313,12 +326,14 @@ export const NewRuleImplementation = ({
           population: [],
           populations: [],
           validations: [{}],
+          segments: [{}],
           rawContent: {
             database: "",
             source_id: null,
             dataset: "",
             population: "",
             validations: "",
+            segments: "",
           },
           dfName: "",
           dfContent: {},
@@ -380,6 +395,12 @@ export const NewRuleImplementation = ({
       _.filter((val) => valueInDataset(val))
     )(ruleImplementation);
 
+    const segments_within_dataset = _.flow(
+      _.prop("segments"),
+      _.filter((val) => belongsToDataset(_.path("structure.id")(val))),
+      _.filter((val) => valueInDataset(val))
+    )(ruleImplementation);
+
     const population_within_dataset = _.flow(
       _.prop("population"),
       _.filter((val) => belongsToDataset(_.path("structure.id")(val))),
@@ -395,16 +416,15 @@ export const NewRuleImplementation = ({
       validations: _.isEmpty(validations_within_dataset)
         ? [{}]
         : validations_within_dataset,
+      segments: _.isEmpty(segments_within_dataset)
+        ? []
+        : segments_within_dataset,
     });
   };
 
   const onChange = (prop, value) =>
     setRuleImplementation({ ...ruleImplementation, [prop]: value });
 
-  const setPopulation = (population) => {
-    setRuleImplementation({ ...ruleImplementation, population });
-  };
-
   const addPopulation = () => {
     const populations = _.concat(
       _.pathOr([], "populations")(ruleImplementation)
@@ -426,6 +446,18 @@ export const NewRuleImplementation = ({
     setRuleImplementation({ ...ruleImplementation, validations });
   };
 
+  const addSegments = () => {
+    const segments = _.concat(_.pathOr([], "segments")(ruleImplementation))([
+      {},
+    ]);
+    setRuleImplementation({ ...ruleImplementation, segments });
+  };
+
+  const setSegments = (segments) => {
+    const newSegments = _.isEqual([{}])(segments) ? [] : segments;
+    setRuleImplementation({ ...ruleImplementation, segments: newSegments });
+  };
+
   const setImplementationKey = (implementationKey) =>
     setRuleImplementation({ ...ruleImplementation, implementationKey });
 
@@ -449,6 +481,7 @@ export const NewRuleImplementation = ({
     const validations = _.filter(_.negate(_.isEmpty))(
       ruleImplementation.validations
     );
+    const segments = _.filter(_.negate(_.isEmpty))(ruleImplementation.segments);
 
     const dfContent = _.flow(
       _.prop("dfContent"),
@@ -481,6 +514,7 @@ export const NewRuleImplementation = ({
             dataset: datasetAttributes(_.prop("dataset")(ruleImplementation)),
             populations: populationsAttributes(populations),
             validations: conditionAttributes(validations),
+            segments,
             implementation_key: _.prop("implementationKey")(ruleImplementation),
             implementation_type:
               _.prop("implementationType")(ruleImplementation),
@@ -562,6 +596,8 @@ export const NewRuleImplementation = ({
                 addPopulation={addPopulation}
                 setPopulations={setPopulations}
                 setValidations={setValidations}
+                addSegments={addSegments}
+                setSegments={setSegments}
                 operators={operators}
                 setImplementationKey={setImplementationKey}
                 onChange={onChange}

package/src/components/RemediationPlan.js

@@ -4,17 +4,14 @@ import PropTypes from "prop-types";
 import { connect } from "react-redux";
 import { useIntl } from "react-intl";
 import { useParams } from "react-router-dom";
-import { Button, Header, Icon, Grid, Segment } from "semantic-ui-react";
+import { Button, Grid, Container } from "semantic-ui-react";
 import { FormattedMessage } from "react-intl";
 import { Loading } from "@truedat/core/components";
 import { ConfirmModal } from "@truedat/core/components";
-import {
-  fetchRemediation,
-  clearRemediation,
-  deleteRemediation,
-} from "../routines";
+import { deleteRemediation } from "../routines";
 import NewRemediation from "./NewRemediation";
 import RemediationForm from "./RemediationForm";
+
 import "../styles/remediationPlan.less";
 
 const DynamicFormViewer = React.lazy(() =>
@@ -23,10 +20,7 @@ const DynamicFormViewer = React.lazy(() =>
 
 export const RemediationPlan = ({
   isLoading,
-  className,
   deleteRemediation,
-  fetchRemediation,
-  clearRemediation,
   remediation,
   templates,
   latestResultId,
@@ -44,17 +38,6 @@ export const RemediationPlan = ({
     setRuleResultId(paramsRuleResultId || latestResultId);
   }, [paramsRuleResultId, latestResultId]);
 
-  useEffect(() => {
-    ruleResultId && fetchRemediation({ rule_result_id: ruleResultId });
-  }, [fetchRemediation, ruleResultId]);
-
-  useEffect(
-    () => () => {
-      clearRemediation();
-    },
-    [clearRemediation]
-  );
-
   const onSave = () => {
     setIsEdit(false);
   };
@@ -70,67 +53,58 @@ export const RemediationPlan = ({
     <>
       {!_.isEmpty(remediation) ? (
         <>
-          <Header as="h2">
-            <Icon circular name="rain" />
-            <Header.Content>
-              <FormattedMessage
-                id={!isEdit ? "remediation" : "remediation.actions.edit"}
+          {manageRemediations ? (
+            <div className="ui actions remediation">
+              <ConfirmModal
+                icon="trash"
+                trigger={<Button secondary icon="trash" basic color="red" />}
+                header={
+                  <FormattedMessage id="remediation.actions.delete.confirmation.header" />
+                }
+                content={
+                  <FormattedMessage
+                    id="remediation.actions.delete.confirmation.content"
+                    values={{ ruleResultId: <b>{ruleResultId}</b> }}
+                  />
+                }
+                onConfirm={() =>
+                  deleteRemediation({
+                    implementation_id: implementationId,
+                    rule_result_id: ruleResultId,
+                  })
+                }
+              />
+              <Button
+                className="button-edit-remediation"
+                primary
+                onClick={() => setIsEdit(!isEdit)}
+                content={formatMessage({
+                  id: !isEdit ? "actions.edit" : "actions.cancel",
+                })}
               />
-            </Header.Content>
-          </Header>
+            </div>
+          ) : null}
 
-          <Segment className={className}>
-            {manageRemediations ? (
-              <div className="ui actions remediation">
-                <ConfirmModal
-                  icon="trash"
-                  trigger={<Button secondary icon="trash" basic color="red" />}
-                  header={
-                    <FormattedMessage id="remediation.actions.delete.confirmation.header" />
-                  }
-                  content={
-                    <FormattedMessage
-                      id="remediation.actions.delete.confirmation.content"
-                      values={{ ruleResultId: <b>{ruleResultId}</b> }}
-                    />
-                  }
-                  onConfirm={() =>
-                    deleteRemediation({
-                      implementation_id: implementationId,
-                      rule_result_id: ruleResultId,
-                    })
-                  }
-                />
-                <Button
-                  className="button-edit-remediation"
-                  primary
-                  onClick={() => setIsEdit(!isEdit)}
-                  content={formatMessage({
-                    id: !isEdit ? "actions.edit" : "actions.cancel",
-                  })}
+          <Grid>
+            <Grid.Column width={8}>
+              {!isEdit && remediation?.df_name ? (
+                <DynamicFormViewer
+                  template={_.find(_.propEq("name", remediation.df_name))(
+                    templates
+                  )}
+                  content={remediation.df_content}
                 />
-              </div>
-            ) : null}
-
-            <Grid>
-              <Grid.Column width={8}>
-                {!isEdit && remediation?.df_name ? (
-                  <DynamicFormViewer
-                    template={_.find(_.propEq("name", remediation.df_name))(
-                      templates
-                    )}
-                    content={remediation.df_content}
-                  />
-                ) : (
+              ) : (
+                <Container className="new-remedation-container" fluid>
                   <RemediationForm
                     onSave={onSave}
                     remediation={remediation}
                     latestResultId={latestResultId}
                   />
-                )}
-              </Grid.Column>
-            </Grid>
-          </Segment>
+                </Container>
+              )}
+            </Grid.Column>
+          </Grid>
         </>
       ) : null}
     </>
@@ -139,10 +113,7 @@ export const RemediationPlan = ({
 
 RemediationPlan.propTypes = {
   isLoading: PropTypes.bool,
-  className: PropTypes.string,
   deleteRemediation: PropTypes.func,
-  clearRemediation: PropTypes.func,
-  fetchRemediation: PropTypes.func,
   remediation: PropTypes.object,
   templates: PropTypes.array,
   latestResultId: PropTypes.number,
@@ -164,6 +135,4 @@ const mapStateToProps = ({
 
 export default connect(mapStateToProps, {
   deleteRemediation,
-  fetchRemediation,
-  clearRemediation,
 })(RemediationPlan);

package/src/components/RuleImplementationProperties.js

@@ -12,7 +12,7 @@ const DynamicFormViewer = React.lazy(() =>
   import("@truedat/df/components/DynamicFormViewer")
 );
 
-const summarySteps = ["dataset", "populations", "validations"];
+const summarySteps = ["dataset", "populations", "validations", "segments"];
 
 export const RuleImplementationProperties = ({
   ruleImplementation,
@@ -75,6 +75,7 @@ const mapStateToProps = ({
   ruleImplementation: _.pick([
     ...summarySteps,
     "populations",
+    "segments",
     "executable",
     "event_type",
     "event_message",

package/src/components/RuleImplementationResultTabs.js

@@ -0,0 +1,113 @@
+import _ from "lodash/fp";
+import React from "react";
+import PropTypes from "prop-types";
+import { Menu } from "semantic-ui-react";
+import { Link, withRouter } from "react-router-dom";
+import { compose } from "redux";
+import { connect } from "react-redux";
+import { FormattedMessage } from "react-intl";
+import {
+  RULE_IMPLEMENTATION_RESULT_DETAILS,
+  RULE_IMPLEMENTATION_RESULT_SEGMENTS_RESULTS,
+  //TODO: change name route
+  RULE_IMPLEMENTATION_RESULT_DETAILS_REMEDIATION_PLAN,
+  linkTo,
+} from "@truedat/core/routes";
+
+import RuleResultRemediationLoader from "./RuleResultRemediationLoader";
+const TemplatesLoader = React.lazy(() =>
+  import("@truedat/df/templates/components/TemplatesLoader")
+);
+
+export const RuleImplementationResultTabs = ({
+  rule,
+  ruleImplementation,
+  ruleResult,
+  match,
+  authCreateRemediation,
+  templates,
+}) => {
+  const renderSegmentResult = () => {
+    return ruleResult.has_segments ? (
+      <Menu.Item
+        active={match.path === RULE_IMPLEMENTATION_RESULT_SEGMENTS_RESULTS}
+        as={Link}
+        to={linkTo.RULE_IMPLEMENTATION_RESULT_SEGMENTS_RESULTS({
+          id: rule.id,
+          implementation_id: ruleImplementation.id,
+          rule_result_id: ruleResult.id,
+        })}
+      >
+        <FormattedMessage id="tabs.dq.ruleImplementationResult.segmentResult" />
+      </Menu.Item>
+    ) : null;
+  };
+
+  const renderRemediationPlan = () => {
+    const canCreateRemediation = authCreateRemediation && !_.isEmpty(templates);
+    const renderCondition = ruleResult.has_remediation || canCreateRemediation;
+
+    return renderCondition ? (
+      <Menu.Item
+        active={
+          match.path === RULE_IMPLEMENTATION_RESULT_DETAILS_REMEDIATION_PLAN
+        }
+        as={Link}
+        to={linkTo.RULE_IMPLEMENTATION_RESULT_DETAILS_REMEDIATION_PLAN({
+          id: rule.id,
+          implementation_id: ruleImplementation.id,
+          rule_result_id: ruleResult.id,
+        })}
+      >
+        <FormattedMessage id="tabs.dq.ruleImplementationResult.remediationPlan" />
+      </Menu.Item>
+    ) : null;
+  };
+
+  return _.isEmpty(ruleImplementation) || _.isEmpty(rule) ? null : (
+    <>
+      <RuleResultRemediationLoader propRuleResultId={ruleResult.id} />
+      <TemplatesLoader scope="remediation" />
+      <Menu attached="top" pointing secondary tabular>
+        <Menu.Item
+          active={match.path === RULE_IMPLEMENTATION_RESULT_DETAILS}
+          as={Link}
+          to={linkTo.RULE_IMPLEMENTATION_RESULT_DETAILS({
+            id: rule.id,
+            implementation_id: ruleImplementation.id,
+            rule_result_id: ruleResult.id,
+          })}
+        >
+          <FormattedMessage id="tabs.dq.ruleImplementationResult.info" />
+        </Menu.Item>
+        {renderSegmentResult()}
+        {renderRemediationPlan()}
+      </Menu>
+    </>
+  );
+};
+
+RuleImplementationResultTabs.propTypes = {
+  rule: PropTypes.object,
+  ruleResult: PropTypes.object,
+  ruleImplementation: PropTypes.object,
+  match: PropTypes.object,
+  authCreateRemediation: PropTypes.bool,
+  templates: PropTypes.array,
+};
+
+const mapStateToProps = (
+  { rule, ruleImplementation, remediationActions, templates },
+  ownProps
+) => ({
+  rule,
+  ruleResult: ownProps.ruleResult,
+  ruleImplementation,
+  authCreateRemediation: _.has("create")(remediationActions),
+  templates,
+});
+
+export default compose(
+  withRouter,
+  connect(mapStateToProps)
+)(RuleImplementationResultTabs);

package/src/components/RuleImplementationResults.js

@@ -1,5 +1,5 @@
 import _ from "lodash/fp";
-import React, { useEffect } from "react";
+import React from "react";
 import PropTypes from "prop-types";
 import { useIntl } from "react-intl";
 import { connect } from "react-redux";

package/src/components/RuleImplementationTabs.js

@@ -10,6 +10,8 @@ import {
   RULE_IMPLEMENTATION_EVENTS,
   IMPLEMENTATION_CONCEPT_LINKS,
   IMPLEMENTATION_CONCEPT_LINKS_NEW,
+  IMPLEMENTATION_STRUCTURES,
+  IMPLEMENTATION_STRUCTURES_NEW,
   RULE_IMPLEMENTATION_MOVE,
   RULE_IMPLEMENTATION_RESULTS_DETAILS,
   RULE_IMPLEMENTATION_RESULTS,
@@ -57,9 +59,22 @@ export const RuleImplementationTabs = ({
             implementation_id: ruleImplementation.id,
           })}
         >
-          <FormattedMessage id="tabs.dq.implementation.links" />
+          <FormattedMessage id="tabs.dq.implementation.links.concepts" />
         </Menu.Item>
       )}
+      <Menu.Item
+        active={
+          match.path === IMPLEMENTATION_STRUCTURES ||
+          match.path === IMPLEMENTATION_STRUCTURES_NEW
+        }
+        as={Link}
+        to={linkTo.IMPLEMENTATION_STRUCTURES({
+          id: rule.id,
+          implementation_id: ruleImplementation.id,
+        })}
+      >
+        <FormattedMessage id="tabs.dq.implementation.structures" />
+      </Menu.Item>
       <Menu.Item
         active={match.path === RULE_IMPLEMENTATION_RESULTS}
         as={Link}

package/src/components/RuleImplementationsTable.js

@@ -15,6 +15,7 @@ export const RuleImplementationsTable = ({
   additionalColumns = [],
   checkedAll,
   checkRow,
+  structure,
   executeImplementationsOn,
   implementationsSort,
   sortImplementations,
@@ -127,6 +128,7 @@ RuleImplementationsTable.propTypes = {
   isRowChecked: PropTypes.bool,
   ruleImplementationsLoading: PropTypes.bool,
   sortImplementations: PropTypes.func,
+  structure: PropTypes.object,
   ruleImplementations: PropTypes.array,
   columns: PropTypes.array,
   withoutColumns: PropTypes.array,
@@ -134,11 +136,16 @@ RuleImplementationsTable.propTypes = {
 
 const mapStateToProps = (state, props) => ({
   columns: getRuleImplementationColumns(state),
-  ruleImplementations: _.getOr(
+  ruleImplementations:
+    props.ruleImplementations ||
+    (state?.structure?.implementations &&
+      _.map(({ implementation, type }) => ({
+        ...implementation,
+        implementation_structure_structure_type: type,
+      }))(state.structure.implementations)) ||
     state.ruleImplementations,
-    "ruleImplementations"
-  )(props),
   ruleImplementationsLoading: state.ruleImplementationsLoading,
+  structure: state.structure,
   implementationsSort: _.path("ruleImplementationQuery.sort")(state),
 });
 

package/src/components/RuleResult.js

@@ -0,0 +1,108 @@
+import _ from "lodash/fp";
+import React from "react";
+import PropTypes from "prop-types";
+import { useIntl } from "react-intl";
+import { connect } from "react-redux";
+import { useParams } from "react-router-dom";
+import { Header, Table, Icon } from "semantic-ui-react";
+import { DateTime } from "@truedat/core/components";
+import { FormattedMessage } from "react-intl";
+import { selectColor } from "../functions/selectors";
+import RuleImplementationResultTabs from "./RuleImplementationResultTabs";
+
+const GeneralInformation = ({ ruleImplementation, ruleResult }) => {
+  const { formatMessage, formatNumber: _formatNumber } = useIntl();
+  const formatNumber = (num) => (_.isNil(num) ? num : _formatNumber(num));
+  return (
+    <>
+      <Table.Row>
+        <Table.Cell>
+          {formatMessage({ id: "ruleResult.props.quality" })}
+        </Table.Cell>
+        <Table.Cell>
+          <Icon
+            name="circle"
+            color={selectColor({ ...ruleImplementation, ...ruleResult })}
+          />
+          {`${parseFloat(ruleResult.result)} %`}
+        </Table.Cell>
+      </Table.Row>
+
+      <Table.Row>
+        <Table.Cell>
+          {formatMessage({ id: "ruleResult.props.date" })}
+        </Table.Cell>
+        <Table.Cell>
+          <DateTime value={ruleResult.date} />
+        </Table.Cell>
+      </Table.Row>
+
+      <Table.Row>
+        <Table.Cell>
+          {formatMessage({ id: "ruleResult.props.records" })}
+        </Table.Cell>
+        <Table.Cell>{formatNumber(ruleResult.records)}</Table.Cell>
+      </Table.Row>
+
+      <Table.Row>
+        <Table.Cell>
+          {formatMessage({ id: "ruleResult.props.errors" })}
+        </Table.Cell>
+        <Table.Cell>{formatNumber(ruleResult.errors)}</Table.Cell>
+      </Table.Row>
+    </>
+  );
+};
+
+GeneralInformation.propTypes = {
+  ruleImplementation: PropTypes.object,
+  ruleResult: PropTypes.object,
+};
+
+export const RuleResult = ({ ruleImplementation, ruleResultId, children }) => {
+  const { rule_result_id: paramsId } = useParams();
+
+  const resultId = _.defaultTo(_.toNumber(paramsId))(ruleResultId);
+
+  const ruleResult = _.find(_.propEq("id", resultId))(
+    ruleImplementation.results
+  );
+
+  const renderRuleResult = () => {
+    return (
+      <>
+        <Header as="h2">
+          <Icon circular name="chart pie" />
+          <Header.Content>
+            <FormattedMessage id="ruleResult" />
+          </Header.Content>
+        </Header>
+        <RuleImplementationResultTabs ruleResult={ruleResult} />
+        {children}
+      </>
+    );
+  };
+
+  return _.isEmpty(ruleResult) ? null : renderRuleResult();
+};
+
+RuleResult.propTypes = {
+  ruleImplementation: PropTypes.object,
+  ruleResultId: PropTypes.number,
+  children: PropTypes.oneOfType([
+    PropTypes.node,
+    PropTypes.arrayOf(PropTypes.node),
+  ]),
+};
+
+const mapStateToProps = (
+  { ruleImplementation, remediationLoading, templatesLoading },
+  ownProps
+) => ({
+  ruleImplementation,
+  remediationLoading,
+  templatesLoading,
+  ...ownProps,
+});
+
+export default connect(mapStateToProps)(RuleResult);

package/src/components/{ExecutionDetails.js → RuleResultDetails.js}

@@ -4,11 +4,9 @@ import PropTypes from "prop-types";
 import { useIntl } from "react-intl";
 import { connect } from "react-redux";
 import { useParams } from "react-router-dom";
-import { Header, Table, Icon } from "semantic-ui-react";
+import { Table, Icon } from "semantic-ui-react";
 import { DateTime } from "@truedat/core/components";
-import { FormattedMessage } from "react-intl";
 import { selectColor } from "../functions/selectors";
-import RemediationPlan from "./RemediationPlan";
 import "../styles/executionDetails.less";
 
 const GeneralInformation = ({ ruleImplementation, ruleResult }) => {
@@ -84,11 +82,7 @@ const DetailRow = ({ details }) => {
 
 DetailRow.propTypes = { details: PropTypes.object };
 
-const TemplatesLoader = React.lazy(() =>
-  import("@truedat/df/templates/components/TemplatesLoader")
-);
-
-export const ExecutionDetails = ({ ruleImplementation, ruleResultId }) => {
+export const RuleResultDetails = ({ ruleImplementation, ruleResultId }) => {
   const { formatMessage } = useIntl();
   const { rule_result_id: paramsId } = useParams();
 
@@ -100,12 +94,6 @@ export const ExecutionDetails = ({ ruleImplementation, ruleResultId }) => {
 
   return _.isEmpty(ruleResult) ? null : (
     <>
-      <Header as="h2">
-        <Icon circular name="chart pie" />
-        <Header.Content>
-          <FormattedMessage id="ruleResult" />
-        </Header.Content>
-      </Header>
       <Table className="implementation-results medium">
         <Table.Header>
           <Table.Row>
@@ -141,16 +129,11 @@ export const ExecutionDetails = ({ ruleImplementation, ruleResultId }) => {
           </>
         ) : null}
       </Table>
-      <TemplatesLoader scope="remediation" />
-      <RemediationPlan
-        className="execution-details-remediation"
-        latestResultId={resultId}
-      />
     </>
   );
 };
 
-ExecutionDetails.propTypes = {
+RuleResultDetails.propTypes = {
   ruleImplementation: PropTypes.object,
   ruleResultId: PropTypes.number,
 };
@@ -159,4 +142,4 @@ const mapStateToProps = ({ ruleImplementation }) => ({
   ruleImplementation,
 });
 
-export default connect(mapStateToProps)(ExecutionDetails);
+export default connect(mapStateToProps)(RuleResultDetails);