@truedat/dq 4.58.2 → 4.58.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [4.58.4] 2022-12-22
+
+### Added
+
+- [TD-4300] Add `basic` type for implementations
+
+## [4.58.3] 2022-12-21
+
+### Changed
+
+- [TD-5426] Update `decode-uri-component` (CVE-2022-38900)
+
 ## [4.56.9] 2022-12-12
 
 ### Added
@@ -10,7 +22,7 @@
 
 ### Added
 
-- # [TD-4179] inserted_at and updated_at columns on Implementations
+- [TD-4179] inserted_at and updated_at columns on Implementations
 
 ## [4.56.6] 2022-11-28
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dq",
-  "version": "4.58.2",
+  "version": "4.58.4",
   "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.58.2",
+    "@truedat/test": "4.58.4",
     "babel-jest": "^28.1.0",
     "babel-plugin-dynamic-import-node": "^2.3.3",
     "babel-plugin-lodash": "^3.3.4",
@@ -92,12 +92,14 @@
   },
   "dependencies": {
     "@apollo/client": "^3.7.1",
-    "@truedat/core": "4.58.2",
-    "@truedat/df": "4.58.2",
+    "@truedat/core": "4.58.4",
+    "@truedat/df": "4.58.4",
+    "decode-uri-component": "^0.2.2",
     "graphql": "^15.5.3",
     "moment": "^2.29.4",
     "path-to-regexp": "^1.7.0",
     "prop-types": "^15.8.1",
+    "query-string": "^6.11.0",
     "rc-slider": "^8.6.1",
     "react-intl": "^5.20.10",
     "react-moment": "^1.1.2",
@@ -116,5 +118,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 2.0.3 < 2.2"
   },
-  "gitHead": "2e7042f380612d48784dc5641085fbe6dba7c7d1"
+  "gitHead": "852f36764d42a458272b3d5a5d204d928d5243c4"
 }

package/src/components/ImplementationsRoutes.js

@@ -16,6 +16,7 @@ import {
   IMPLEMENTATION_HISTORY,
   IMPLEMENTATION_MOVE,
   IMPLEMENTATION_NEW,
+  IMPLEMENTATION_NEW_BASIC,
   IMPLEMENTATION_NEW_RAW,
   IMPLEMENTATION_RESULT_DETAILS,
   IMPLEMENTATION_RESULTS_DETAILS,
@@ -38,6 +39,7 @@ import ImplementationStructuresNew from "./ImplementationStructuresNew";
 import Implementations from "./Implementations";
 import MoveImplementation from "./MoveImplementation";
 import NewRuleImplementation from "./NewRuleImplementation";
+import NewBasicRuleImplementation from "./NewBasicRuleImplementation";
 import RuleImplementation from "./RuleImplementation";
 import RuleImplementationEvents from "./RuleImplementationEvents";
 import RuleImplementationHistory from "./RuleImplementationHistory";
@@ -77,6 +79,7 @@ export const ImplementationsRoutes = ({
   ruleImplementationLoaded,
   structuresAliasesLoading,
   systemsLoading,
+  isRuleImplemenationBasic,
 }) => {
   const authorized = useAuthorized();
   const { rule_result_id: ruleResultId } = useParams();
@@ -93,6 +96,16 @@ export const ImplementationsRoutes = ({
           </>
         )}
       />
+      <Route
+        exact
+        path={IMPLEMENTATION_NEW_BASIC}
+        render={() => (
+          <>
+            <TemplatesLoader scope="ri" />
+            <NewBasicRuleImplementation />
+          </>
+        )}
+      />
       <Route
         exact
         path={IMPLEMENTATION_NEW_RAW}
@@ -174,7 +187,11 @@ export const ImplementationsRoutes = ({
                   {!structuresAliasesLoading &&
                   ruleImplementationLoaded &&
                   implementationStructuresLoaded ? (
-                    <NewRuleImplementation edition clone />
+                    isRuleImplemenationBasic ? (
+                      <NewBasicRuleImplementation edition clone />
+                    ) : (
+                      <NewRuleImplementation edition clone />
+                    )
                   ) : null}
                 </>
               )}
@@ -192,7 +209,11 @@ export const ImplementationsRoutes = ({
                   {!structuresAliasesLoading &&
                   ruleImplementationLoaded &&
                   implementationStructuresLoaded ? (
-                    <NewRuleImplementation edition />
+                    isRuleImplemenationBasic ? (
+                      <NewBasicRuleImplementation edition />
+                    ) : (
+                      <NewRuleImplementation edition />
+                    )
                   ) : null}
                 </>
               )}
@@ -379,6 +400,7 @@ ImplementationsRoutes.propTypes = {
   ruleImplementationLoaded: PropTypes.bool,
   structuresAliasesLoading: PropTypes.bool,
   systemsLoading: PropTypes.bool,
+  isRuleImplemenationBasic: PropTypes.bool,
 };
 
 export const mapStateToProps = (state) => ({
@@ -388,6 +410,8 @@ export const mapStateToProps = (state) => ({
     !state.ruleImplementationLoading && !_.isEmpty(state.ruleImplementation),
   structuresAliasesLoading: state.structuresAliasesLoading,
   systemsLoading: state.systemsLoading,
+  isRuleImplemenationBasic:
+    state.ruleImplementation?.implementation_type == "basic",
 });
 
 export default connect(mapStateToProps)(ImplementationsRoutes);

package/src/components/NewBasicRuleImplementation.js

@@ -0,0 +1,139 @@
+import _ from "lodash/fp";
+import React, { useState } from "react";
+import PropTypes from "prop-types";
+import { connect } from "react-redux";
+import { FormattedMessage } from "react-intl";
+import { Divider, Header, Grid } from "semantic-ui-react";
+import {
+  createRuleImplementation,
+  updateRuleImplementation,
+} from "../routines";
+import RuleImplementationBasicForm from "./ruleImplementationForm/RuleImplementationBasicForm";
+
+export const NewBasicRuleImplementation = ({
+  clone = false,
+  createRuleImplementation,
+  updateRuleImplementation,
+  edition = false,
+  ruleImplementationProps,
+  rule,
+}) => {
+  const [ruleImplementation, setRuleImplementation] = useState(
+    edition
+      ? {
+          id: clone ? null : ruleImplementationProps.id,
+          implementationKey: clone
+            ? ""
+            : ruleImplementationProps.implementation_key,
+          dfName: ruleImplementationProps.df_name,
+          dfContent: ruleImplementationProps.df_content,
+          result_type: ruleImplementationProps.result_type,
+          minimum: ruleImplementationProps.minimum,
+          goal: ruleImplementationProps.goal,
+          rule: ruleImplementationProps.rule_id
+            ? ruleImplementationProps.rule
+            : null,
+          rule_id: ruleImplementationProps.rule_id,
+          domain_id: ruleImplementationProps.domain_id,
+          status: ruleImplementationProps.status,
+        }
+      : {
+          implementationKey: "",
+          dfName: "",
+          dfContent: {},
+          result_type: "percentage",
+          minimum: null,
+          goal: null,
+          rule_id: _.propOr(null, "id")(rule),
+          domain_id: rule?.domain_id || null,
+          rule: rule,
+        }
+  );
+
+  const onChange = (prop, value) =>
+    setRuleImplementation((prevValue) => ({ ...prevValue, [prop]: value }));
+
+  const setImplementationKey = (implementationKey) =>
+    setRuleImplementation({ ...ruleImplementation, implementationKey });
+
+  const doSubmit = (props = {}) => {
+    const rule_implementation = {
+      executable: false,
+      implementation_key: ruleImplementation.implementationKey,
+      implementation_type: "basic",
+      df_name: ruleImplementation?.dfName,
+      df_content: ruleImplementation?.dfContent,
+      rule_id: ruleImplementation.rule_id,
+      result_type: ruleImplementation.result_type,
+      minimum: ruleImplementation.minimum,
+      goal: ruleImplementation.goal,
+      domain_id: ruleImplementation.domain_id,
+      status: props?.status,
+    };
+    clone || !edition
+      ? createRuleImplementation({
+          rule_implementation,
+          redirectUrl: null,
+        })
+      : updateRuleImplementation({
+          rule_implementation: {
+            ...rule_implementation,
+            id: ruleImplementation.id,
+          },
+        });
+  };
+
+  return (
+    <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>
+          <RuleImplementationBasicForm
+            mode={clone ? "clone" : edition ? "edition" : ""}
+            implementationKey={ruleImplementation.implementationKey}
+            setImplementationKey={setImplementationKey}
+            ruleImplementation={ruleImplementation}
+            onChange={onChange}
+            onSubmit={doSubmit}
+          />
+        </Grid.Row>
+      </Grid.Column>
+      <Grid.Column width="5"></Grid.Column>
+    </Grid>
+  );
+};
+
+NewBasicRuleImplementation.propTypes = {
+  clone: PropTypes.bool,
+  createRuleImplementation: PropTypes.func.isRequired,
+  edition: PropTypes.bool,
+  ruleImplementationProps: PropTypes.object,
+  updateRuleImplementation: PropTypes.func,
+};
+
+const mapStateToProps = (state) => ({
+  rule: state.rule,
+  ruleImplementationProps: {
+    ...state.ruleImplementation,
+  },
+});
+
+export default connect(mapStateToProps, {
+  createRuleImplementation,
+  updateRuleImplementation,
+})(NewBasicRuleImplementation);

package/src/components/NewRuleImplementation.js

@@ -276,10 +276,7 @@ export const NewRuleImplementation = ({
           implementationKey: clone
             ? ""
             : ruleImplementationProps.implementation_key,
-          implementationType:
-            ruleImplementationProps.implementation_type == "draft"
-              ? "default"
-              : ruleImplementationProps.implementation_type,
+          implementationType: ruleImplementationProps.implementation_type,
           dataset: precalculatedDataset,
           populations: _.flow(
             _.pathOr([], "populations"),

package/src/components/RuleImplementationActions.js

@@ -6,11 +6,25 @@ import { Link, useParams } from "react-router-dom";
 import { Button } from "semantic-ui-react";
 import { linkTo } from "@truedat/core/routes";
 
-const RuleImplementationActions = ({ canCreate, canCreateRaw }) => {
+const RuleImplementationActions = ({
+  canCreate,
+  canCreateRaw,
+  canCreateBasic,
+}) => {
   const { formatMessage } = useIntl();
   const params = useParams();
   return (
     <>
+      {canCreateBasic && (
+        <Button
+          as={Link}
+          to={linkTo.IMPLEMENTATION_NEW_BASIC(params)}
+          className="primary_action"
+          content={formatMessage({
+            id: "implementations.actions.create_basic",
+          })}
+        />
+      )}
       {canCreateRaw && (
         <Button
           as={Link}
@@ -35,11 +49,13 @@ const RuleImplementationActions = ({ canCreate, canCreateRaw }) => {
 RuleImplementationActions.propTypes = {
   canCreate: PropTypes.bool,
   canCreateRaw: PropTypes.bool,
+  canCreateBasic: PropTypes.bool,
 };
 
 const mapStateToProps = ({ implementationActions }) => ({
   canCreate: !!implementationActions?.create,
   canCreateRaw: !!implementationActions?.createRaw,
+  canCreateBasic: !!implementationActions?.createBasic,
 });
 
 export default connect(mapStateToProps)(RuleImplementationActions);

package/src/components/RuleImplementationsActions.js

@@ -102,6 +102,7 @@ export const RuleImplementationsActions = ({
       <RuleImplementationsOptions
         loading={ruleImplementationsLoading}
         canUploadResults={canUploadResults}
+        canCreateBasicImplementations={!!actions?.createBasicRuleLess}
       />
     </div>
   );

package/src/components/RuleImplementationsOptions.js

@@ -1,29 +1,52 @@
 import React from "react";
 import PropTypes from "prop-types";
 import { Dropdown } from "semantic-ui-react";
+import { useIntl } from "react-intl";
+import { Link } from "react-router-dom";
+import { IMPLEMENTATION_NEW_BASIC } from "@truedat/core/routes";
 import RuleImplementationsDownload from "./RuleImplementationsDownload";
 import RuleResultsUpload from "./RuleResultsUpload";
 import ImplementationsUploadButton from "./ImplementationsUploadButton";
 
-export const RuleImplementationsOptions = ({ loading, canUploadResults }) => (
-  <Dropdown
-    icon="ellipsis vertical"
-    className="button icon group-actions button-update"
-    direction="left"
-    floating
-    disabled={loading}
-  >
-    <Dropdown.Menu>
-      <RuleImplementationsDownload />
-      <ImplementationsUploadButton />
-      {canUploadResults ? <RuleResultsUpload /> : null}
-    </Dropdown.Menu>
-  </Dropdown>
-);
+export const RuleImplementationsOptions = ({
+  loading,
+  canUploadResults,
+  canCreateBasicImplementations,
+}) => {
+  const { formatMessage } = useIntl();
+  return (
+    <Dropdown
+      icon="ellipsis vertical"
+      className="button icon group-actions button-update"
+      direction="left"
+      floating
+      disabled={loading}
+    >
+      <Dropdown.Menu>
+        {canCreateBasicImplementations ? (
+          <Dropdown.Item
+            name="implementation_basic"
+            icon="file alternate"
+            as={Link}
+            to={IMPLEMENTATION_NEW_BASIC}
+            content={formatMessage({
+              id: "implementations.actions.create_basic",
+            })}
+            onClick={(e) => e.stopPropagation()}
+          />
+        ) : null}
+        <RuleImplementationsDownload />
+        <ImplementationsUploadButton />
+        {canUploadResults ? <RuleResultsUpload /> : null}
+      </Dropdown.Menu>
+    </Dropdown>
+  );
+};
 
 RuleImplementationsOptions.propTypes = {
   loading: PropTypes.bool,
   canUploadResults: PropTypes.bool,
+  canCreateBasicImplementations: PropTypes.bool,
 };
 
 export default RuleImplementationsOptions;

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

@@ -0,0 +1,166 @@
+import _ from "lodash/fp";
+import React from "react";
+import { waitFor } from "@testing-library/react";
+import { render } from "@truedat/test/render";
+import { DOMAIN_QUERY, DOMAINS_QUERY } from "@truedat/core/api/queries";
+import { multipleTemplatesMock } from "@truedat/test/mocks";
+import userEvent from "@testing-library/user-event";
+import NewBasicRuleImplementation from "../NewBasicRuleImplementation";
+import {
+  createRuleImplementation,
+  updateRuleImplementation,
+} from "../../routines";
+
+const ruleImplementationLoaderActions = {
+  createRuleImplementation,
+  updateRuleImplementation,
+};
+
+const ruleImplementation = {
+  deleted_at: null,
+  df_content: {},
+  df_name: "fooDomain",
+  domain_id: 1,
+  id: 1330,
+  implementation_key: "bar_impl",
+  implementation_type: "basic",
+  goal: 20,
+  minimum: 10,
+  result_type: "percentage",
+  results: [],
+  rule_id: null,
+  status: "draft",
+  version: 1,
+};
+
+const domainActions = ["publishImplementation", "manageSegments"];
+const domains = [
+  {
+    id: "2",
+    externalId: "td",
+    name: "Truedat",
+    parentId: "",
+    actions: domainActions,
+  },
+];
+const requestVariables = {
+  action: "manageBasicRulelessImplementations",
+  domainActions: domainActions,
+};
+const domainsMock = {
+  request: { query: DOMAINS_QUERY, variables: requestVariables },
+  result: { data: { domains: domains } },
+};
+const domainMock = {
+  request: {
+    query: DOMAIN_QUERY,
+    variables: { id: 2, actions: ["publishImplementation"] },
+  },
+  result: { data: { domain: { id: "2", actions: domainActions } } },
+};
+
+describe("<NewBasicRuleImplementation />", () => {
+  const createRuleImplementation = jest.fn();
+  const updateRuleImplementation = jest.fn();
+
+  const props = {
+    ruleImplementation,
+    createRuleImplementation,
+    updateRuleImplementation,
+  };
+  const renderOpts = {
+    mocks: [
+      multipleTemplatesMock({
+        scope: "ri",
+        domainIds: null,
+      }),
+      domainsMock,
+      domainMock,
+    ],
+    fallback: "lazy",
+  };
+
+  it("matches the latest snapshot", async () => {
+    const { container, queryByText } = render(
+      <NewBasicRuleImplementation {...props} />,
+      renderOpts
+    );
+
+    await waitFor(() => expect(queryByText(/lazy/i)).not.toBeInTheDocument());
+    await waitFor(() =>
+      expect(queryByText(/loading/i)).not.toBeInTheDocument()
+    );
+    expect(container).toMatchSnapshot();
+  });
+});
+
+describe("<NewBasicRuleImplementation> NewBasicRuleImplementation doSubmit", () => {
+  const dispatch = jest.fn();
+
+  const renderOptsImplementationEdit = {
+    mocks: [
+      multipleTemplatesMock({
+        scope: "ri",
+        domainIds: [1],
+      }),
+      domainsMock,
+      domainMock,
+    ],
+    state: {
+      rule: {},
+      ruleImplementation,
+    },
+    fallback: "lazy",
+    dispatch,
+  };
+
+  const props = {
+    ...ruleImplementationLoaderActions,
+    edition: true,
+  };
+
+  const expectedRuleImplementationBase = {
+    df_content: {},
+    df_name: "template1",
+    domain_id: 1,
+    executable: false,
+    goal: 20,
+    id: 1329 + 1,
+    implementation_key: "bar_impl",
+    implementation_type: "basic",
+    minimum: 10,
+    result_type: "percentage",
+    rule_id: null,
+    status: "draft",
+  };
+
+  it("doSubmit", async () => {
+    const expectedRuleImplementation = {
+      ...expectedRuleImplementationBase,
+    };
+
+    const { queryByText, getByRole, findByRole } = render(
+      <NewBasicRuleImplementation {...props} />,
+      renderOptsImplementationEdit
+    );
+
+    // Information Form
+
+    await waitFor(() => {
+      expect(queryByText(/Template/)).toBeTruthy();
+    });
+
+    userEvent.click(await findByRole("option", { name: "template1" }));
+
+    await waitFor(() => {
+      expect(getByRole("button", { name: "Save" })).toBeEnabled();
+    });
+
+    userEvent.click(await getByRole("button", { name: "Save" }));
+
+    expect(dispatch).toHaveBeenCalledWith({
+      ...ruleImplementationLoaderActions.updateRuleImplementation(),
+      payload: { rule_implementation: expectedRuleImplementation },
+    });
+  });
+});