@truedat/dq 4.36.9 → 4.37.3

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

@@ -1,10 +1,11 @@
+import { applyUserSearchFilter } from "@truedat/dd/routines";
 import { initialState } from "../ruleImplementationActiveFilters";
 import {
   addImplementationFilter,
   closeImplementationFilter,
   removeImplementationFilter,
   resetImplementationFilters,
-  toggleImplementationFilterValue
+  toggleImplementationFilterValue,
 } from "../../routines";
 import { ruleImplementationActiveFilters } from "..";
 
@@ -17,13 +18,24 @@ describe("reducers: ruleImplementationActiveFilters", () => {
     );
   });
 
+  it("should handle the applyUserSearchFilter.TRIGGER action", () => {
+    const filters = { country: ["Sp"] };
+    const payload = { userFilter: { filters }, scope: "rule_implementation" };
+    expect(
+      ruleImplementationActiveFilters(fooState, {
+        type: applyUserSearchFilter.TRIGGER,
+        payload,
+      })
+    ).toEqual({ ...filters });
+  });
+
   it("should handle the addImplementationFilter.TRIGGER action", () => {
     const filter = "baz";
     const payload = { filter };
     expect(
       ruleImplementationActiveFilters(fooState, {
         type: addImplementationFilter.TRIGGER,
-        payload
+        payload,
       })
     ).toEqual({ ...fooState, baz: [] });
   });
@@ -36,7 +48,7 @@ describe("reducers: ruleImplementationActiveFilters", () => {
     expect(
       ruleImplementationActiveFilters(state, {
         type: closeImplementationFilter.TRIGGER,
-        payload
+        payload,
       })
     ).toEqual({ foo });
   });
@@ -49,7 +61,7 @@ describe("reducers: ruleImplementationActiveFilters", () => {
     expect(
       ruleImplementationActiveFilters(state, {
         type: removeImplementationFilter.TRIGGER,
-        payload
+        payload,
       })
     ).toEqual({ bar });
   });
@@ -57,7 +69,7 @@ describe("reducers: ruleImplementationActiveFilters", () => {
   it("should handle the resetImplementationFilters.TRIGGER action", () => {
     expect(
       ruleImplementationActiveFilters(fooState, {
-        type: resetImplementationFilters.TRIGGER
+        type: resetImplementationFilters.TRIGGER,
       })
     ).toEqual(initialState);
   });
@@ -67,7 +79,7 @@ describe("reducers: ruleImplementationActiveFilters", () => {
       ruleImplementationActiveFilters(
         { ...fooState, executable: [true] },
         {
-          type: resetImplementationFilters.TRIGGER
+          type: resetImplementationFilters.TRIGGER,
         }
       )
     ).toEqual({ executable: [true] });
@@ -81,7 +93,7 @@ describe("reducers: ruleImplementationActiveFilters", () => {
     expect(
       ruleImplementationActiveFilters(state, {
         type: toggleImplementationFilterValue.TRIGGER,
-        payload
+        payload,
       })
     ).toEqual({ foo: ["foo1", "foo3"], bar });
   });

package/src/reducers/index.js

@@ -17,7 +17,6 @@ import { ruleImplementation } from "./ruleImplementation";
 import { ruleImplementationCount } from "./ruleImplementationCount";
 import { ruleImplementationCreating } from "./ruleImplementationCreating";
 import { ruleImplementationFilters } from "./ruleImplementationFilters";
-import { ruleImplementationFilterValues } from "./ruleImplementationFilterValues";
 import { ruleImplementationLoading } from "./ruleImplementationLoading";
 import { ruleImplementationQuery } from "./ruleImplementationQuery";
 import { ruleImplementationRaw } from "./ruleImplementationRaw";
@@ -65,7 +64,6 @@ export {
   ruleImplementationCount,
   ruleImplementationCreating,
   ruleImplementationFilters,
-  ruleImplementationFilterValues,
   ruleImplementationLoading,
   ruleImplementationQuery,
   ruleImplementationRaw,

package/src/reducers/ruleActiveFilters.js

@@ -1,4 +1,5 @@
 import _ from "lodash/fp";
+import { applyUserSearchFilter } from "@truedat/dd/routines";
 import {
   addRuleFilter,
   closeRuleFilter,
@@ -15,6 +16,10 @@ export const ruleActiveFilters = (state = initialState, { type, payload }) => {
       const { filter } = payload;
       return { ...state, [filter]: [] };
     }
+    case applyUserSearchFilter.TRIGGER: {
+      const { userFilter, scope } = payload;
+      return scope === "rule" ? _.prop("filters")(userFilter) : state;
+    }
     case closeRuleFilter.TRIGGER: {
       const { filter } = payload;
       const values = _.propOr([], filter)(state);

package/src/reducers/ruleImplementationActiveFilters.js

@@ -1,4 +1,5 @@
 import _ from "lodash/fp";
+import { applyUserSearchFilter } from "@truedat/dd/routines";
 import {
   addImplementationFilter,
   closeImplementationFilter,
@@ -18,6 +19,12 @@ export const ruleImplementationActiveFilters = (
       const { filter } = payload;
       return { ...state, [filter]: [] };
     }
+    case applyUserSearchFilter.TRIGGER: {
+      const { userFilter, scope } = payload;
+      return scope === "rule_implementation"
+        ? _.prop("filters")(userFilter)
+        : state;
+    }
     case closeImplementationFilter.TRIGGER: {
       const { filter } = payload;
       const values = _.propOr([], filter)(state);

package/src/routines.js

@@ -48,9 +48,6 @@ export const updateDeletionQuery = createRoutine("UPDATE_DELETION_QUERY");
 export const uploadRules = createRoutine("UPLOAD_RULES");
 export const uploadImplementations = createRoutine("UPLOAD_IMPLEMENTATIONS");
 export const clearStructure = createRoutine("CLEAR_STRUCTURE");
-export const setImplementationFilterValues = createRoutine(
-  "SET_IMPLEMENTATION_FILTER_VALUES"
-);
 export const searchRuleImplementations = createRoutine(
   "SEARCH_RULE_IMPLEMENTATIONS"
 );

package/src/selectors/__tests__/datasetDefaultFiltersSelector.spec.js

@@ -0,0 +1,17 @@
+import {
+  datasetDefaultFiltersSelector,
+  defaultFilters,
+} from "../datasetDefaultFiltersSelector";
+
+describe("datasetDefaultFiltersSelector", () => {
+  it("returns datasetDefaultFilters if present the state", () => {
+    const datasetDefaultFilters = { "class.raw": ["foo", "bar"] };
+    const state = { datasetDefaultFilters };
+    expect(datasetDefaultFiltersSelector(state)).toBe(datasetDefaultFilters);
+  });
+
+  it("returns the default value if datasetDefaultFilters is not present in the state", () => {
+    const state = {};
+    expect(datasetDefaultFiltersSelector(state)).toBe(defaultFilters);
+  });
+});

package/src/selectors/__tests__/getParsedEvents.spec.js

@@ -0,0 +1,173 @@
+import { getParsedEvents } from "..";
+
+describe("selectors: getParsedEvents", () => {
+  const events = [
+    {
+      id: 52351,
+      service: "td_dd",
+      resource_id: 777,
+      resource_type: "rule",
+      event: "rule_created",
+      payload: {
+        active: true,
+        content: {
+          added: {
+            data_owner: null,
+            proyecto: ["P1"],
+          },
+        },
+        description: {},
+        df_name: "dq_default_template",
+        domain_id: 2,
+        goal: 20,
+        minimum: 80,
+        name: "des01",
+        result_type: "deviation",
+        updated_by: 398,
+      },
+      user_id: 398,
+      user_name: null,
+      user: {
+        email: "some.user@domain.tld",
+        full_name: "Some User",
+        id: 398,
+        user_name: "some.user@domain.tld",
+      },
+      ts: "2021-08-12T12:11:26.908147Z",
+    },
+
+    {
+      id: 100217,
+      service: "td_dd",
+      resource_id: 777,
+      resource_type: "rule",
+      event: "rule_updated",
+      payload: {
+        domain_id: 140,
+      },
+      user_id: 142,
+      user_name: null,
+      user: {
+        email: "some.user@domain.tld",
+        full_name: "Some User",
+        id: 142,
+        user_name: "some.user@domain.tld",
+      },
+      ts: "2021-09-16T07:36:32.848603Z",
+    },
+    {
+      id: 100435,
+      service: "td_dd",
+      resource_id: 777,
+      resource_type: "rule",
+      event: "rule_updated",
+      payload: {
+        description: {
+          document: {
+            data: {},
+            nodes: [
+              {
+                data: {},
+                nodes: [
+                  {
+                    marks: [],
+                    object: "text",
+                    text: "Añadimos descripción a la regla",
+                  },
+                ],
+                object: "block",
+                type: "paragraph",
+              },
+            ],
+            object: "document",
+          },
+          object: "value",
+        },
+        updated_by: 171,
+      },
+      user_id: 171,
+      user_name: null,
+      user: {
+        email: "some.user@domain.tld",
+        full_name: "Some User",
+        id: 171,
+        user_name: "some.user",
+      },
+      ts: "2021-09-16T09:30:52.317357Z",
+    },
+    {
+      id: 177692,
+      service: "td_dd",
+      resource_id: 777,
+      resource_type: "rule",
+      event: "rule_updated",
+      payload: {
+        content: {
+          changed: {
+            data_stew: null,
+            principle: "Validez",
+            scheduler: "",
+            tags: "et",
+          },
+          removed: {
+            data_owner: null,
+            proyecto: ["P1"],
+          },
+        },
+        df_name: "quality_template",
+        updated_by: 426,
+      },
+      user_id: 426,
+      user_name: null,
+      user: {
+        email: "some.user@domain.tld",
+        full_name: "Some User",
+        id: 426,
+        user_name: "some.user",
+      },
+      ts: "2021-10-20T07:56:45.891087Z",
+    },
+  ];
+
+  const parsed = [
+    {
+      ...events[0],
+      payload: [{ field: "des01", action: "created" }],
+    },
+    {
+      ...events[1],
+      payload: [{ field: "domain_id", action: "changed", value: 140 }],
+    },
+    {
+      ...events[2],
+      payload: [
+        {
+          field: "description",
+          action: "changed",
+          value: "Añadimos descripción a la regla",
+        },
+      ],
+    },
+    {
+      ...events[3],
+      payload: [
+        { field: "df_name", action: "changed", value: "quality_template" },
+        { action: "changed", field: "data_stew", value: null },
+        { action: "changed", field: "principle", value: "Validez" },
+        { action: "changed", field: "scheduler", value: "" },
+        { action: "changed", field: "tags", value: "et" },
+      ],
+    },
+  ];
+
+  it("should return all the events with the new payload", () => {
+    const res = getParsedEvents({ events });
+    expect(res).toEqual(parsed);
+  });
+
+  it("should return empty array when we have no elements", () => {
+    const res = getParsedEvents({ events: [] });
+    expect(res).toHaveLength(0);
+    expect(res).toEqual(expect.arrayContaining([]));
+  });
+});

package/src/selectors/datasetDefaultFiltersSelector.js

@@ -0,0 +1,8 @@
+import _ from "lodash/fp";
+
+export const defaultFilters = { "class.raw": ["table"] };
+
+export const datasetDefaultFiltersSelector = _.propOr(
+  defaultFilters,
+  "datasetDefaultFilters"
+);

package/src/selectors/getParsedEvents.js

@@ -8,6 +8,24 @@ const getEvents = ({ events }) => {
 const transformFieldFormat = (field) =>
   _.isBoolean(field) ? _.toString(field) : field;
 
+const findDeep = (obj, key) =>
+  _.has(key, obj)
+    ? obj[key]
+    : _.flatten(
+        _.map((v) => (typeof v == "object" ? findDeep(v, key) : []), obj)
+      );
+
+const transformRulePayloadFormat = (payload, field) => {
+  switch (field) {
+    case "content":
+      return payload.content;
+    case "description":
+      return _.first(findDeep(payload.description, "text"));
+    default:
+      return payload[field];
+  }
+};
+
 const getParsedEvents = createSelector([getEvents], (events) => {
   return _.map((d) => {
     switch (d.event) {
@@ -68,6 +86,43 @@ const getParsedEvents = createSelector([getEvents], (events) => {
             }))
           )(d),
         };
+      case "rule_created":
+        return {
+          ...d,
+          payload: [
+            {
+              field: _.path("payload.name")(d),
+              action: "created",
+            },
+          ],
+        };
+
+      case "rule_updated":
+        const content = _.flow(
+          _.getOr({}, "payload.content.changed"),
+          _.toPairs,
+          _.map(([field, value]) => ({
+            field,
+            value,
+            action: "changed",
+          }))
+        )(d);
+        return {
+          ...d,
+          payload: [
+            ..._.flow(
+              _.path("payload"),
+              _.omit(["updated_by", "content"]),
+              _.keys,
+              _.map((field) => ({
+                field: field,
+                action: "changed",
+                value: transformRulePayloadFormat(d.payload, field),
+              }))
+            )(d),
+            ...content,
+          ],
+        };
 
       default:
         return {

package/src/selectors/index.js

@@ -1,3 +1,4 @@
+export { datasetDefaultFiltersSelector } from "./datasetDefaultFiltersSelector";
 export { getImplementationsExecution } from "./getImplementationsExecution";
 export { getRuleAvailableFilters } from "./getRuleAvailableFilters";
 export { getRuleSelectedFilters } from "./getRuleSelectedFilters";
@@ -22,7 +23,6 @@ export {
   defaultImplementationColumns,
 } from "./getRuleImplementationColumns";
 export { getPreviousRuleImplementationQuery } from "./getPreviousRuleImplementationQuery";
-export { getRuleImplementationFormFilters } from "./getRuleImplementationFormFilters";
 export { getRuleImplementationAvailableFilters } from "./getRuleImplementationAvailableFilters";
 export { getRuleImplementationSelectedFilters } from "./getRuleImplementationSelectedFilters";
 export { getRuleImplementationSelectedFilterValues } from "./getRuleImplementationSelectedFilterValues";

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

@@ -1,36 +0,0 @@
-import { clearRule, setImplementationFilterValues } from "../../routines";
-import { ruleImplementationFilterValues } from "..";
-
-const fooState = { foo: "bar" };
-const value = { system: { name: "Whatever" } };
-
-describe("reducers: ruleImplementationFilterValues", () => {
-  const initialState = null;
-
-  it("should provide the initial state", () => {
-    expect(ruleImplementationFilterValues(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the setImplementationFilterValues.TRIGGER action", () => {
-    expect(
-      ruleImplementationFilterValues(fooState, {
-        type: setImplementationFilterValues.TRIGGER,
-        payload: { value }
-      })
-    ).toEqual(value);
-  });
-
-  it("should handle the clearRule.TRIGGER action", () => {
-    expect(
-      ruleImplementationFilterValues(fooState, {
-        type: clearRule.TRIGGER
-      })
-    ).toEqual(null);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(ruleImplementationFilterValues(fooState, { type: "FOO" })).toBe(
-      fooState
-    );
-  });
-});

package/src/reducers/ruleImplementationFilterValues.js

@@ -1,20 +0,0 @@
-import { clearRule, setImplementationFilterValues } from "../routines";
-
-/** @type {string} */
-export const initialState = null;
-
-export const ruleImplementationFilterValues = (
-  state = initialState,
-  { type, payload }
-) => {
-  switch (type) {
-    case setImplementationFilterValues.TRIGGER: {
-      const { value } = payload;
-      return value;
-    }
-    case clearRule.TRIGGER:
-      return initialState;
-    default:
-      return state;
-  }
-};

package/src/selectors/__tests__/getRuleImplementationFormFilters.spec.js

@@ -1,22 +0,0 @@
-import { getRuleImplementationFormFilters } from "..";
-
-const ruleImplementationFormFilters = [
-  { name: "system.name", filter: "system.name.raw", values: v => [v] }
-];
-
-const ruleImplementationFilterValues = { system: { name: "foo" } };
-
-describe("selectors: getRuleImplementationFormFilters", () => {
-  it("should return null when params do not exists", () => {
-    const res = getRuleImplementationFormFilters({});
-    expect(res).toMatchObject({});
-  });
-
-  it("should return default filters", () => {
-    const res = getRuleImplementationFormFilters({
-      ruleImplementationFormFilters,
-      ruleImplementationFilterValues
-    });
-    expect(res).toMatchObject({ "system.name.raw": ["foo"] });
-  });
-});

package/src/selectors/getRuleImplementationFormFilters.js

@@ -1,19 +0,0 @@
-import _ from "lodash/fp";
-import { createSelector } from "reselect";
-
-export const getRuleImplementationFormFilters = createSelector(
-  [
-    _.prop("ruleImplementationFilterValues"),
-    _.prop("ruleImplementationFormFilters")
-  ],
-  (ruleImplementationFilterValues, ruleImplementationFormFilters) =>
-    ruleImplementationFilterValues && ruleImplementationFormFilters
-      ? _.reduce(
-          (acc, { name, filter, values }) => ({
-            ...acc,
-            [filter]: values(_.path(name)(ruleImplementationFilterValues))
-          }),
-          {}
-        )(ruleImplementationFormFilters)
-      : {}
-);