@truedat/dq 4.33.10 → 4.35.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/__tests__/uploadingResults.spec.js

@@ -0,0 +1,28 @@
+import { uploadResults } from "../../routines";
+import { uploadingResults } from "..";
+
+const fooState = { foo: "bar" };
+
+const initialState = false;
+
+describe("reducers: previousRuleImplementationQuery", () => {
+  it("should provide the initial state", () => {
+    expect(uploadingResults(undefined, {})).toEqual(initialState);
+  });
+
+  it("should handle the uploadResults.TRIGGER action", () => {
+    expect(
+      uploadingResults(fooState, {
+        type: uploadResults.TRIGGER,
+      })
+    ).toBeTruthy();
+  });
+
+  it("should handle the uploadResults.FULFILL action", () => {
+    expect(
+      uploadingResults(fooState, {
+        type: uploadResults.FULFILL,
+      })
+    ).toBeFalsy();
+  });
+});

package/src/reducers/dqMessage.js

@@ -1,5 +1,125 @@
+import _ from "lodash/fp";
+import { dismissAlert } from "@truedat/core/routines";
+import { uploadRules, uploadImplementations, uploadResults } 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;
+      }
+    case uploadResults.SUCCESS:
+      return {
+        error: false,
+        header: "ruleResults.upload.success.header",
+        icon: "check",
+        color: "green",
+        text: "",
+      };
+    case uploadResults.FAILURE:
+      if (payload.status != 500) {
+        return {
+          error: true,
+          header: "ruleResults.upload.failed.header",
+          content: `ruleResults.upload.failed.content`,
+          icon: "attention",
+          text: "",
+          fields: { row: _.path("data.row")(payload) },
+        };
+      } else {
+        return null;
+      }
+
+    default:
+      return state;
+  }
+};
 
 export { dqMessage };

package/src/reducers/index.js

@@ -37,9 +37,12 @@ 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";
+import { uploadingResults } from "./uploadingResults";
 
 export {
   conceptRules,
@@ -81,7 +84,10 @@ export {
   rules,
   rulesLoading,
   rulesPageSize,
+  uploadRulesFile,
+  uploadImplementationsFile,
   userRulePermissions,
   userRulesPermissions,
   userImplementationsPermissions,
+  uploadingResults,
 };

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/reducers/uploadingResults.js

@@ -0,0 +1,16 @@
+import { uploadResults } from "../routines";
+
+const initialState = false;
+
+export const uploadingResults = (state = initialState, { type }) => {
+  switch (type) {
+    case uploadResults.TRIGGER:
+      return true;
+    case uploadResults.FULFILL:
+      return false;
+    default:
+      return state;
+  }
+};
+
+export default uploadingResults;

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"
@@ -87,6 +89,7 @@ export const openImplementationFilter = createRoutine(
 export const downloadImplementations = createRoutine(
   "DOWNLOAD_IMPLEMENTATIONS"
 );
+export const uploadResults = createRoutine("UPLOAD_RESULTS");
 export const createExecutionGroup = createRoutine("CREATE_EXECUTION_GROUP");
 export const fetchExecutionGroup = createRoutine("FETCH_EXECUTION_GROUP");
 export const clearExecutionGroup = createRoutine("CLEAR_EXECUTION_GROUP");

package/src/sagas/__tests__/uploadResults.spec.js

@@ -0,0 +1,65 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJsonPost, UPLOAD_JSON_OPTS } from "@truedat/core/services/api";
+import { uploadResultsRequestSaga, uploadResultsSaga } from "../uploadResults";
+import { uploadResults } from "../../routines";
+import { API_RULE_RESULTS } from "../../api";
+
+describe("sagas: uploadResultsRequestSaga", () => {
+  it("should invoke uploadResultsSaga on trigger", () => {
+    expect(() => {
+      testSaga(uploadResultsRequestSaga)
+        .next()
+        .takeLatest(uploadResults.TRIGGER, uploadResultsSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(uploadResultsRequestSaga)
+        .next()
+        .takeLatest("FOO", uploadResultsSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: uploadResultsSaga", () => {
+  const body = { rule_results: "content" };
+  const payload = { data: body };
+  const data = { message: [1, 2] };
+  it("should put a success action when a response is returned", () => {
+    expect(() => {
+      testSaga(uploadResultsSaga, { payload })
+        .next()
+        .put(uploadResults.request())
+        .next()
+        .call(apiJsonPost, API_RULE_RESULTS, body, UPLOAD_JSON_OPTS)
+        .next({ data })
+        .put(uploadResults.success(data))
+        .next()
+        .put(uploadResults.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should put a failure action when the call returns an error", () => {
+    const message = "Request failed";
+    const error = { message };
+
+    expect(() => {
+      testSaga(uploadResultsSaga, { payload })
+        .next()
+        .put(uploadResults.request())
+        .next()
+        .call(apiJsonPost, API_RULE_RESULTS, body, UPLOAD_JSON_OPTS)
+        .throw(error)
+        .put(uploadResults.failure(message))
+        .next()
+        .put(uploadResults.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

package/src/sagas/index.js

@@ -14,8 +14,11 @@ 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";
+import { uploadResultsRequestSaga } from "./uploadResults";
 
 export {
   createExecutionGroupRequestSaga,
@@ -34,8 +37,11 @@ export {
   fetchRuleRequestSaga,
   fetchRulesRequestSaga,
   searchRuleImplementationsRequestSaga,
+  uploadRulesRequestsSaga,
+  uploadImplementationsRequestsSaga,
   updateRuleImplementationRequestSaga,
   updateRuleRequestSaga,
+  uploadResultsRequestSaga,
 };
 
 export default [
@@ -55,6 +61,9 @@ export default [
   fetchRuleRequestSaga(),
   fetchRulesRequestSaga(),
   searchRuleImplementationsRequestSaga(),
+  uploadRulesRequestsSaga(),
+  uploadImplementationsRequestsSaga(),
   updateRuleImplementationRequestSaga(),
   updateRuleRequestSaga(),
+  uploadResultsRequestSaga(),
 ];

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/uploadResults.js

@@ -0,0 +1,32 @@
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJsonPost, UPLOAD_JSON_OPTS } from "@truedat/core/services/api";
+import { uploadResults } from "../routines";
+import { API_RULE_RESULTS } from "../api";
+
+export function* uploadResultsSaga({ payload }) {
+  try {
+    const { data: body } = payload;
+    yield put(uploadResults.request());
+    const { data } = yield call(
+      apiJsonPost,
+      API_RULE_RESULTS,
+      body,
+      UPLOAD_JSON_OPTS
+    );
+
+    yield put(uploadResults.success(data));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(uploadResults.failure({ status, data }));
+    } else {
+      yield put(uploadResults.failure(error.message));
+    }
+  } finally {
+    yield put(uploadResults.fulfill());
+  }
+}
+
+export function* uploadResultsRequestSaga() {
+  yield takeLatest(uploadResults.TRIGGER, uploadResultsSaga);
+}

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);
+}