@truedat/dq 4.33.8 → 4.34.2

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

@@ -20,18 +20,16 @@ describe("reducers: rule", () => {
       current_business_concept_version: { name: "alfalfa", id: 1234 },
       name: "rule1",
       description: "desc1",
-      goal: 10,
-      minimum: 1,
       active: false,
       domain_id: 1,
-      domain: { id: 1, name: "foo", external_id: "bar" }
+      domain: { id: 1, name: "foo", external_id: "bar" },
     };
     const payload = { data: someRule };
 
     expect(
       rule(fooState, {
         type: fetchRule.SUCCESS,
-        payload
+        payload,
       })
     ).toMatchObject(someRule);
   });

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

@@ -21,6 +21,8 @@ describe("reducers: ruleImplementation", () => {
       id: 2,
       implementation_key: "xxx",
       results: [],
+      goal: 10,
+      minimum: 1,
     };
     const payload = { data: ruleImpl };
 

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

@@ -1,7 +1,7 @@
 import {
   clearRuleImplementations,
   fetchRuleImplementations,
-  searchRuleImplementations
+  searchRuleImplementations,
 } from "../../routines";
 import { ruleImplementations } from "..";
 
@@ -9,12 +9,16 @@ const fooState = { foo: "bar" };
 const data = [
   {
     id: 1,
-    implementation_key: "RuleImplementations 1"
+    implementation_key: "RuleImplementations 1",
+    goal: 10,
+    minimum: 1,
   },
   {
     id: 2,
-    implementation_key: "RuleImplementations 2"
-  }
+    implementation_key: "RuleImplementations 2",
+    goal: 10,
+    minimum: 1,
+  },
 ];
 
 describe("reducers: ruleImplementations", () => {
@@ -27,7 +31,7 @@ describe("reducers: ruleImplementations", () => {
   it("should handle the fetchRuleImplementations.TRIGGER action", () => {
     expect(
       ruleImplementations(fooState, {
-        type: fetchRuleImplementations.TRIGGER
+        type: fetchRuleImplementations.TRIGGER,
       })
     ).toMatchObject(initialState);
   });
@@ -38,7 +42,7 @@ describe("reducers: ruleImplementations", () => {
     expect(
       ruleImplementations(fooState, {
         type: fetchRuleImplementations.SUCCESS,
-        payload
+        payload,
       })
     ).toMatchObject(data);
   });
@@ -49,7 +53,7 @@ describe("reducers: ruleImplementations", () => {
     expect(
       ruleImplementations(fooState, {
         type: searchRuleImplementations.SUCCESS,
-        payload
+        payload,
       })
     ).toMatchObject(data);
   });
@@ -57,7 +61,7 @@ describe("reducers: ruleImplementations", () => {
   it("should handle the clearRuleImplementations.TRIGGER action", () => {
     expect(
       ruleImplementations(fooState, {
-        type: clearRuleImplementations.TRIGGER
+        type: clearRuleImplementations.TRIGGER,
       })
     ).toMatchObject(initialState);
   });

package/src/reducers/dqMessage.js

@@ -1,5 +1,104 @@
+import _ from "lodash/fp";
+import { dismissAlert } from "@truedat/core/routines";
+import { uploadRules, uploadImplementations } from "../routines";
+
 const initialState = {};
 
-const dqMessage = () => initialState;
+const dqMessage = (state = initialState, { type, payload }) => {
+  switch (type) {
+    case dismissAlert.TRIGGER:
+      return initialState;
+    case uploadRules.SUCCESS:
+      const messages = _.has("errors")(payload.data)
+        ? _.flow(
+            _.propOr([], "errors"),
+            _.map((error) => ({
+              id: "rules.upload.success.errors",
+              fields: {
+                rule_name: error.rule_name,
+                key: Object.keys(error.message)[0],
+                message: error.message[Object.keys(error.message)[0]][0],
+              },
+              defaultMessage: "rules.upload.success.errors.default",
+            }))
+          )(payload.data)
+        : "";
+      return {
+        error: false,
+        header: "rules.upload.success.header",
+        icon: "check",
+        color: payload.data.errors.length >= 1 ? "orange" : "green",
+        text: "",
+        messages,
+        fields: {
+          count_ids: payload.data.ids.length,
+          count_errors: payload.data.errors.length,
+        },
+      };
+    case uploadRules.FAILURE:
+      if (payload.status != 500 && !_.path("data.errors")(payload)) {
+        return {
+          error: true,
+          header: "rules.upload.failed.header",
+          content: `rules.upload.failed.${
+            _.path("data.error.error")(payload) || _.path("data.error")(payload)
+          }`,
+          icon: "attention",
+          text: "",
+          fields: _.path("data.error")(payload),
+        };
+      } else {
+        return null;
+      }
+
+    case uploadImplementations.SUCCESS:
+      const messagesImp = _.has("errors")(payload.data)
+        ? _.flow(
+            _.propOr([], "errors"),
+            _.map((error) => ({
+              id: "ruleImplementations.upload.success.errors",
+              fields: {
+                name: error.implementation_key,
+                key: Object.keys(error.message)[0],
+                message: error.message[Object.keys(error.message)[0]][0],
+              },
+              defaultMessage:
+                "ruleImplementations.upload.success.errors.default",
+            }))
+          )(payload.data)
+        : "";
+
+      return {
+        error: false,
+        header: "ruleImplementations.upload.success.header",
+        icon: "check",
+        color: payload.data.errors.length >= 1 ? "orange" : "green",
+        text: "",
+        messages: messagesImp,
+        fields: {
+          count_ids: payload.data.ids.length,
+          count_errors: payload.data.errors.length,
+        },
+      };
+    case uploadImplementations.FAILURE:
+      if (payload.status != 500 && !_.path("data.errors")(payload)) {
+        return {
+          error: true,
+          header: "ruleImplementations.upload.failed.header",
+          content: `ruleImplementations.upload.failed.${
+            _.path("data.error.error")(payload) || _.path("data.error")(payload)
+          }`,
+          icon: "attention",
+          text: "",
+          fields: _.path("data.error")(payload),
+        };
+      } else {
+        return null;
+      }
+
+    default:
+      return state;
+  }
+};
 
 export { dqMessage };

package/src/reducers/index.js

@@ -37,6 +37,8 @@ import { ruleUpdating } from "./ruleUpdating";
 import { rules } from "./rules";
 import { rulesLoading } from "./rulesLoading";
 import { rulesPageSize } from "./rulesPageSize";
+import { uploadImplementationsFile } from "./uploadImplementationsFile";
+import { uploadRulesFile } from "./uploadRulesFile";
 import { userRulePermissions } from "./userRulePermissions";
 import { userRulesPermissions } from "./userRulesPermissions";
 import { userImplementationsPermissions } from "./userImplementationsPermissions";
@@ -81,6 +83,8 @@ export {
   rules,
   rulesLoading,
   rulesPageSize,
+  uploadRulesFile,
+  uploadImplementationsFile,
   userRulePermissions,
   userRulesPermissions,
   userImplementationsPermissions,

package/src/reducers/rule.js

@@ -13,13 +13,10 @@ const pickFields = _.pick([
   "current_business_concept_version",
   "name",
   "description",
-  "goal",
-  "minimum",
   "system_values",
   "type_params",
   "df_name",
   "df_content",
-  "result_type"
 ]);
 
 const rule = (state = initialState, { type, payload }) => {

package/src/reducers/ruleImplementation.js

@@ -21,6 +21,9 @@ const pickFields = _.pick([
   "rule_id",
   "system",
   "validations",
+  "result_type",
+  "minimum",
+  "goal",
 ]);
 
 const ruleImplementation = (state = initialState, { type, payload }) => {

package/src/reducers/ruleImplementationRedirect.js

@@ -5,13 +5,14 @@ import {
   createRuleImplementation,
   updateRuleImplementation,
   deleteRuleResult,
+  uploadImplementations,
 } from "../routines";
 
 const initialState = "";
 
 export const ruleImplementationRedirect = (
   state = initialState,
-  { type, payload }
+  { type, payload, meta }
 ) => {
   switch (type) {
     case clearRedirect.TRIGGER:
@@ -29,6 +30,10 @@ export const ruleImplementationRedirect = (
       const { id: implementation_id, rule_id: id } = data;
       return linkTo.RULE_IMPLEMENTATION({ id, implementation_id });
     }
+    case uploadImplementations.SUCCESS: {
+      const { redirectUrl } = meta;
+      return redirectUrl;
+    }
     case deleteRuleResult.SUCCESS: {
       const { rule_implementation_id: implementation_id, rule_id: id } =
         payload;

package/src/reducers/ruleImplementations.js

@@ -21,6 +21,9 @@ const pickFields = _.pick([
   "event_type",
   "event_inserted_at",
   "deleted_at",
+  "result_type",
+  "minimum",
+  "goal",
   "dataset",
   "valdations",
 ]);

package/src/reducers/ruleRedirect.js

@@ -11,6 +11,7 @@ import {
   updateRule,
   deleteRule,
   setRuleImplementationStatus,
+  uploadRules,
 } from "../routines";
 
 const initialState = "";
@@ -37,6 +38,10 @@ export const ruleRedirect = (state = initialState, { type, payload, meta }) => {
       const { rule_id } = payload;
       return _.isNil(rule_id) ? state : linkTo.RULE({ id: rule_id });
     }
+    case uploadRules.SUCCESS: {
+      const { redirectUrl } = meta;
+      return redirectUrl;
+    }
     case deleteSubscription.SUCCESS: {
       const { rule_id } = payload;
       return _.isNil(rule_id) ? state : linkTo.RULE({ id: rule_id });

package/src/reducers/uploadImplementationsFile.js

@@ -0,0 +1,28 @@
+import { uploadImplementations } from "../routines";
+
+const initialState = {
+  loading: false,
+  error: {},
+};
+
+export const uploadImplementationsFile = (
+  state = initialState,
+  { type, payload }
+) => {
+  switch (type) {
+    case uploadImplementations.TRIGGER:
+      return state;
+    case uploadImplementations.REQUEST:
+      return { ...state, loading: true };
+    case uploadImplementations.SUCCESS:
+      return state;
+    case uploadImplementations.FAILURE:
+      return { ...state, error: payload };
+    case uploadImplementations.FULFILL:
+      return { ...state, loading: false };
+    default:
+      return state;
+  }
+};
+
+export default uploadImplementationsFile;

package/src/reducers/uploadRulesFile.js

@@ -0,0 +1,25 @@
+import { uploadRules } from "../routines";
+
+const initialState = {
+  loading: false,
+  error: {},
+};
+
+export const uploadRulesFile = (state = initialState, { type, payload }) => {
+  switch (type) {
+    case uploadRules.TRIGGER:
+      return state;
+    case uploadRules.REQUEST:
+      return { ...state, loading: true };
+    case uploadRules.SUCCESS:
+      return state;
+    case uploadRules.FAILURE:
+      return { ...state, error: payload };
+    case uploadRules.FULFILL:
+      return { ...state, loading: false };
+    default:
+      return state;
+  }
+};
+
+export default uploadRulesFile;

package/src/routines.js

@@ -45,6 +45,8 @@ export const sortRules = createRoutine("SORT_RULES");
 export const selectRulePage = createRoutine("SELECT_RULE_PAGE");
 export const toggleRuleFilterValue = createRoutine("TOGGLE_RULE_FILTER_VALUE");
 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"

package/src/sagas/index.js

@@ -14,6 +14,8 @@ import { fetchRuleImplementationsRequestSaga } from "./fetchRuleImplementations"
 import { fetchRuleRequestSaga } from "./fetchRule";
 import { fetchRulesRequestSaga } from "./fetchRules";
 import { searchRuleImplementationsRequestSaga } from "./searchRuleImplementations";
+import { uploadImplementationsRequestsSaga } from "./uploadImplementations";
+import { uploadRulesRequestsSaga } from "./uploadRules";
 import { updateRuleImplementationRequestSaga } from "./updateRuleImplementation";
 import { updateRuleRequestSaga } from "./updateRule";
 
@@ -34,6 +36,8 @@ export {
   fetchRuleRequestSaga,
   fetchRulesRequestSaga,
   searchRuleImplementationsRequestSaga,
+  uploadRulesRequestsSaga,
+  uploadImplementationsRequestsSaga,
   updateRuleImplementationRequestSaga,
   updateRuleRequestSaga,
 };
@@ -55,6 +59,8 @@ export default [
   fetchRuleRequestSaga(),
   fetchRulesRequestSaga(),
   searchRuleImplementationsRequestSaga(),
+  uploadRulesRequestsSaga(),
+  uploadImplementationsRequestsSaga(),
   updateRuleImplementationRequestSaga(),
   updateRuleRequestSaga(),
 ];

package/src/sagas/uploadImplementations.js

@@ -0,0 +1,28 @@
+import { call, put, takeLatest } from "redux-saga/effects";
+import { IMPLEMENTATIONS } from "@truedat/core/routes";
+import { apiJsonPost, UPLOAD_JSON_OPTS } from "@truedat/core/services/api";
+import { uploadImplementations } from "../routines";
+
+export function* uploadImplementationsSaga({ payload }) {
+  try {
+    const { action, method, href, ...rest } = payload;
+    const meta = { action, method, href, redirectUrl: IMPLEMENTATIONS };
+    yield put(uploadImplementations.request({ method, href, ...rest }));
+    const body = rest || {};
+    const { data } = yield call(apiJsonPost, href, body.data, UPLOAD_JSON_OPTS);
+    yield put({ meta, ...uploadImplementations.success(data) });
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(uploadImplementations.failure({ status, data }));
+    } else {
+      yield put(uploadImplementations.failure(error.message));
+    }
+  } finally {
+    yield put(uploadImplementations.fulfill());
+  }
+}
+
+export function* uploadImplementationsRequestsSaga() {
+  yield takeLatest(uploadImplementations.TRIGGER, uploadImplementationsSaga);
+}

package/src/sagas/uploadRules.js

@@ -0,0 +1,28 @@
+import { call, put, takeLatest } from "redux-saga/effects";
+import { RULES } from "@truedat/core/routes";
+import { apiJsonPost, UPLOAD_JSON_OPTS } from "@truedat/core/services/api";
+import { uploadRules } from "../routines";
+
+export function* uploadRulesSaga({ payload }) {
+  try {
+    const { action, method, href, ...rest } = payload;
+    const meta = { action, method, href, redirectUrl: RULES };
+    yield put(uploadRules.request({ method, href, ...rest }));
+    const body = rest || {};
+    const { data } = yield call(apiJsonPost, href, body.data, UPLOAD_JSON_OPTS);
+    yield put({ meta, ...uploadRules.success(data) });
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(uploadRules.failure({ status, data }));
+    } else {
+      yield put(uploadRules.failure(error.message));
+    }
+  } finally {
+    yield put(uploadRules.fulfill());
+  }
+}
+
+export function* uploadRulesRequestsSaga() {
+  yield takeLatest(uploadRules.TRIGGER, uploadRulesSaga);
+}

package/src/selectors/getRuleImplementationColumns.js

@@ -1,10 +1,18 @@
 import _ from "lodash/fp";
+import React from "react";
 import { createSelector } from "reselect";
+import { FormattedMessage } from "react-intl";
 import DateTime from "@truedat/core/components/DateTime";
+import { formatNumber } from "@truedat/core/services/format";
 import RuleResultDecorator from "../components/RuleResultDecorator";
 import RuleImplementationLink from "../components/RuleImplementationLink";
 import RuleLink from "../components/RuleLink";
 
+const translateDecorator = (id) => <FormattedMessage id={id} />;
+
+const resultTypeDecorator = (result, result_type) =>
+  result_type === "errors_number" ? formatNumber(result) : `${result}%`;
+
 export const defaultImplementationColumns = [
   {
     name: "implementation_key",
@@ -35,11 +43,38 @@ export const defaultImplementationColumns = [
     sort: { name: "execution_result_info.date" },
     width: 2,
   },
+  {
+    name: "result_type",
+    fieldDecorator: (value) =>
+      _.isNil(value)
+        ? null
+        : translateDecorator(`ruleImplementations.props.result_type.${value}`),
+    sort: { name: "result_type.raw" },
+    width: 2,
+  },
+  {
+    name: "minimum",
+    fieldSelector: _.pick(["minimum", "result_type"]),
+    fieldDecorator: (field) =>
+      resultTypeDecorator(field.minimum, field.result_type),
+    sort: { name: "minimum" },
+    textAlign: "right",
+    width: 1,
+  },
+  {
+    name: "goal",
+    fieldSelector: _.pick(["goal", "result_type"]),
+    fieldDecorator: (field) =>
+      resultTypeDecorator(field.goal, field.result_type),
+    sort: { name: "goal" },
+    textAlign: "right",
+    width: 1,
+  },
   {
     name: "result",
-    fieldSelector: ({ execution_result_info: ruleResult, rule }) => ({
-      ruleResult,
-      rule,
+    fieldSelector: (ruleImplementation) => ({
+      ruleResult: ruleImplementation?.execution_result_info,
+      ruleImplementation,
     }),
     fieldDecorator: RuleResultDecorator,
     textAlign: "center",

package/src/selectors/ruleColumnsSelector.js

@@ -3,14 +3,10 @@ import React from "react";
 import { Label } from "semantic-ui-react";
 import { FormattedMessage } from "react-intl";
 import { createSelector } from "reselect";
-import { formatNumber } from "@truedat/core/services/format";
 import RuleLink from "../components/RuleLink";
 
 const translateDecorator = (id) => <FormattedMessage id={id} />;
 
-const resultTypeDecorator = (result, result_type) =>
-  result_type === "errors_number" ? formatNumber(result) : `${result}%`;
-
 export const dynamicDecorator = (field) => (
   <>
     {field &&
@@ -52,33 +48,6 @@ export const defaultRuleColumns = () => [
     sort: { name: "current_business_concept_version.name.raw" },
     width: 3,
   },
-  {
-    name: "result_type",
-    fieldDecorator: (value) =>
-      _.isNil(value)
-        ? null
-        : translateDecorator(`rule.props.result_type.${value}`),
-    sort: { name: "result_type.raw" },
-    width: 2,
-  },
-  {
-    name: "minimum",
-    fieldSelector: _.pick(["minimum", "result_type"]),
-    fieldDecorator: (field) =>
-      resultTypeDecorator(field.minimum, field.result_type),
-    sort: { name: "minimum" },
-    textAlign: "right",
-    width: 1,
-  },
-  {
-    name: "goal.list",
-    fieldSelector: _.pick(["goal", "result_type"]),
-    fieldDecorator: (field) =>
-      resultTypeDecorator(field.goal, field.result_type),
-    sort: { name: "goal" },
-    textAlign: "right",
-    width: 1,
-  },
 ];
 
 export const optionalRuleColumns = [

package/src/styles/ruleSummary.less

@@ -7,7 +7,7 @@
   height: 18px;
   border-radius: 9px;
   margin: 0px auto;
-  >span>span {
+  > span > span {
     color: white;
   }
 }
@@ -21,39 +21,46 @@
   transition: all 100ms ease-in-out;
   overflow: hidden;
 
-  span:first-child{
+  span:first-child {
     margin-left: 0px;
   }
 
-  span:last-child{
+  span:last-child {
     margin-right: 0px;
   }
 
-  span{
+  span {
     margin: 1px;
     cursor: default;
     color: transparent;
     text-align: center;
     font-size: 10px;
     line-height: 15px;
+    white-space: pre;
   }
 }
 
 .rule-summary {
   @import "~semantic-ui-less/definitions/globals/site";
   .over-goal-color {
-      background-color: @overGoalRuleColor;
+    background-color: @overGoalRuleColor;
   }
   .under-goal-color {
-      background-color: @underGoalRuleColor;
+    background-color: @underGoalRuleColor;
   }
   .under-minimum-color {
-      background-color: @underMinimumRuleColor;
+    background-color: @underMinimumRuleColor;
   }
   .not-executed-color {
-      background-color: @notExecutedRuleColor;
+    background-color: @notExecutedRuleColor;
   }
   .failed-color {
-      background-color: @failedRuleColor;
+    background-color: @failedRuleColor;
   }
-}
+}
+
+.pointer {
+  span {
+    cursor: pointer;
+  }
+}