@truedat/dq 4.40.7 → 4.40.8

package/src/reducers/remediation.js

@@ -0,0 +1,35 @@
+import _ from "lodash/fp";
+import {
+  fetchRemediation,
+  clearRemediation,
+  createRemediation,
+  updateRemediation,
+  deleteRemediation,
+} from "../routines";
+
+const initialState = {};
+
+const remediation = (state = initialState, { type, payload }) => {
+  switch (type) {
+    case deleteRemediation.SUCCESS:
+      return initialState;
+    case clearRemediation.TRIGGER:
+      return initialState;
+    case fetchRemediation.TRIGGER:
+      return initialState;
+    case fetchRemediation.SUCCESS:
+      return _.prop("data")(payload);
+    case fetchRemediation.FAILURE:
+      return _.prop("status")(payload) === 404
+        ? state
+        : _.prop("data")(payload);
+    case createRemediation.SUCCESS:
+      return _.prop("data")(payload);
+    case updateRemediation.SUCCESS:
+      return _.prop("data")(payload);
+    default:
+      return state;
+  }
+};
+
+export { remediation };

package/src/reducers/remediationActions.js

@@ -0,0 +1,19 @@
+import _ from "lodash/fp";
+import { clearRemediation, fetchRemediation } from "../routines";
+
+const initialState = {};
+
+const remediationActions = (state = initialState, { type, payload }) => {
+  switch (type) {
+    case fetchRemediation.SUCCESS:
+      return _.pathOr(initialState, "_actions")(payload);
+    case clearRemediation.TRIGGER:
+      return initialState;
+    case fetchRemediation.TRIGGER:
+      return initialState;
+    default:
+      return state;
+  }
+};
+
+export { remediationActions };

package/src/reducers/remediationLoading.js

@@ -0,0 +1,29 @@
+import {
+  clearRemediation,
+  createRemediation,
+  fetchRemediation,
+  updateRemediation,
+} from "../routines";
+
+const remediationLoading = (state = true, { type }) => {
+  switch (type) {
+    case createRemediation.TRIGGER:
+      return true;
+    case createRemediation.FULFILL:
+      return false;
+    case updateRemediation.TRIGGER:
+      return true;
+    case updateRemediation.FULFILL:
+      return false;
+    case fetchRemediation.TRIGGER:
+      return true;
+    case fetchRemediation.FULFILL:
+      return false;
+    case clearRemediation.TRIGGER:
+      return true;
+    default:
+      return state;
+  }
+};
+
+export { remediationLoading };

package/src/routines.js

@@ -6,6 +6,11 @@ export const clearRule = createRoutine("CLEAR_RULE");
 export const fetchRule = createRoutine("FETCH_RULE");
 export const updateRule = createRoutine("UPDATE_RULE");
 
+export const createRemediation = createRoutine("CREATE_REMEDIATION");
+export const updateRemediation = createRoutine("UPDATE_REMEDIATION");
+export const clearRemediation = createRoutine("CLEAR_REMEDIATION");
+export const deleteRemediation = createRoutine("DELETE_REMEDIATION");
+
 export const clearRuleImplementations = createRoutine(
   "CLEAR_RULE_IMPLEMENTATIONS"
 );
@@ -90,3 +95,4 @@ 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");
+export const fetchRemediation = createRoutine("FETCH_REMEDIATION");

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

@@ -0,0 +1,83 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import { compile } from "path-to-regexp";
+import {
+  createRemediationRequestSaga,
+  createRemediationSaga,
+} from "../createRemediation";
+import { createRemediation, fetchRuleImplementation } from "../../routines";
+import { API_REMEDIATION_PLAN } from "../../api";
+
+describe("sagas: createRemediationRequestSaga", () => {
+  it("should invoke createRemediationSaga on createRemediation.TRIGGER", () => {
+    expect(() => {
+      testSaga(createRemediationRequestSaga)
+        .next()
+        .takeLatest(createRemediation.TRIGGER, createRemediationSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(createRemediationRequestSaga)
+        .next()
+        .takeLatest("FOO", createRemediationSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: createRemediationSaga", () => {
+  const implementationId = 1;
+  const ruleResultId = 1;
+  const remediation = {
+    id: 1,
+    df_name: "remediation_template",
+    df_content: { text: "some_text" },
+  };
+  const payload = {
+    remediation,
+    implementation_id: implementationId,
+    rule_result_id: ruleResultId,
+  };
+  const url = compile(API_REMEDIATION_PLAN)({ rule_result_id: ruleResultId });
+  const requestData = { remediation };
+
+  it("should put a success action when a response is returned", () => {
+    expect(() => {
+      testSaga(createRemediationSaga, { payload })
+        .next()
+        .put(createRemediation.request(remediation))
+        .next()
+        .call(apiJsonPost, url, requestData, JSON_OPTS)
+        .next({ data: remediation })
+        .put(createRemediation.success({ ...payload, ...remediation }))
+        .next()
+        .put(fetchRuleImplementation.trigger({ id: implementationId }))
+        .next()
+        .put(createRemediation.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(createRemediationSaga, { payload })
+        .next()
+        .put(createRemediation.request(remediation))
+        .next()
+        .call(apiJsonPost, url, requestData, JSON_OPTS)
+        .throw(error)
+        .put(createRemediation.failure(message))
+        .next()
+        .put(createRemediation.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,82 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJsonDelete, JSON_OPTS } from "@truedat/core/services/api";
+import { compile } from "path-to-regexp";
+import {
+  deleteRemediationRequestSaga,
+  deleteRemediationSaga,
+} from "../deleteRemediation";
+import { deleteRemediation, fetchRuleImplementation } from "../../routines";
+import { API_REMEDIATION_PLAN } from "../../api";
+
+describe("sagas: deleteRemediationRequestSaga", () => {
+  it("should invoke deleteRemediationSaga on deleteRemediation.TRIGGER", () => {
+    expect(() => {
+      testSaga(deleteRemediationRequestSaga)
+        .next()
+        .takeLatest(deleteRemediation.TRIGGER, deleteRemediationSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(deleteRemediationRequestSaga)
+        .next()
+        .takeLatest("FOO", deleteRemediationSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: deleteRemediationSaga", () => {
+  const ruleResultId = 1;
+  const implementationId = 1;
+  const remediation = {
+    id: 1,
+    df_name: "remediation_template",
+    df_content: { text: "some_text" },
+  };
+  const payload = {
+    remediation,
+    implementation_id: implementationId,
+    rule_result_id: ruleResultId,
+  };
+  const url = compile(API_REMEDIATION_PLAN)({ rule_result_id: ruleResultId });
+
+  it("should put a success action when a response is returned", () => {
+    expect(() => {
+      testSaga(deleteRemediationSaga, { payload })
+        .next()
+        .put(deleteRemediation.request(remediation))
+        .next()
+        .call(apiJsonDelete, url, JSON_OPTS)
+        .next({ data: remediation })
+        .put(deleteRemediation.success({ ...payload, ...remediation }))
+        .next()
+        .put(fetchRuleImplementation.trigger({ id: implementationId }))
+        .next()
+        .put(deleteRemediation.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(deleteRemediationSaga, { payload })
+        .next()
+        .put(deleteRemediation.request(remediation))
+        .next()
+        .call(apiJsonDelete, url, JSON_OPTS)
+        .throw(error)
+        .put(deleteRemediation.failure(message))
+        .next()
+        .put(deleteRemediation.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,78 @@
+import { compile } from "path-to-regexp";
+import { testSaga } from "redux-saga-test-plan";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import {
+  fetchRemediationRequestSaga,
+  fetchRemediationSaga,
+} from "../fetchRemediation";
+import { fetchRemediation } from "../../routines";
+import { API_REMEDIATION_PLAN } from "../../api";
+
+describe("sagas: fetchRemediationRequestSaga", () => {
+  it("should invoke fetchRemediationSaga on trigger", () => {
+    expect(() => {
+      testSaga(fetchRemediationRequestSaga)
+        .next()
+        .takeLatest(fetchRemediation.TRIGGER, fetchRemediationSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(fetchRemediationRequestSaga)
+        .next()
+        .takeLatest("FOO", fetchRemediationSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: fetchRemediaitonSaga", () => {
+  it("should put a success action when a response is returned", () => {
+    const ruleResultId = 1;
+    const url = compile(API_REMEDIATION_PLAN)({ rule_result_id: ruleResultId });
+    const payload = { rule_result_id: ruleResultId };
+    const data = {
+      id: 1,
+      df_name: "remediation_template",
+      df_content: { text: "some_text" },
+    };
+
+    expect(() => {
+      testSaga(fetchRemediationSaga, { payload })
+        .next()
+        .put(fetchRemediation.request())
+        .next()
+        .call(apiJson, url, JSON_OPTS)
+        .next({ data })
+        .put(fetchRemediation.success(data))
+        .next()
+        .put(fetchRemediation.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should put a failure action when the call returns an error", () => {
+    const message = "Request failed";
+    const error = { message };
+    const ruleResultId = 1;
+    const url = compile(API_REMEDIATION_PLAN)({ rule_result_id: ruleResultId });
+    const payload = { rule_result_id: ruleResultId };
+
+    expect(() => {
+      testSaga(fetchRemediationSaga, { payload })
+        .next()
+        .put(fetchRemediation.request())
+        .next()
+        .call(apiJson, url, JSON_OPTS)
+        .throw(error)
+        .put(fetchRemediation.failure(message))
+        .next()
+        .put(fetchRemediation.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

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

@@ -3,7 +3,7 @@ import { testSaga } from "redux-saga-test-plan";
 import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
 import {
   fetchRuleImplementationRequestSaga,
-  fetchRuleImplementationSaga
+  fetchRuleImplementationSaga,
 } from "../fetchRuleImplementation";
 import { fetchRuleImplementation } from "../../routines";
 import { API_RULE_IMPLEMENTATION } from "../../api";

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

@@ -0,0 +1,81 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJsonPut, JSON_OPTS } from "@truedat/core/services/api";
+import { compile } from "path-to-regexp";
+import {
+  updateRemediationRequestSaga,
+  updateRemediationSaga,
+} from "../updateRemediation";
+import { updateRemediation } from "../../routines";
+import { API_REMEDIATION_PLAN } from "../../api";
+
+describe("sagas: updateRemediationRequestSaga", () => {
+  it("should invoke updateRemediationSaga on updateRemediation.TRIGGER", () => {
+    expect(() => {
+      testSaga(updateRemediationRequestSaga)
+        .next()
+        .takeLatest(updateRemediation.TRIGGER, updateRemediationSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(updateRemediationRequestSaga)
+        .next()
+        .takeLatest("FOO", updateRemediationSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: updateRemediationSaga", () => {
+  const implementationId = 1;
+  const ruleResultId = 1;
+  const remediation = {
+    id: 1,
+    df_name: "remediation_template",
+    df_content: { text: "some_text" },
+  };
+  const payload = {
+    remediation,
+    implementation_id: implementationId,
+    rule_result_id: ruleResultId,
+  };
+  const url = compile(API_REMEDIATION_PLAN)({ rule_result_id: ruleResultId });
+  const requestData = { remediation };
+
+  it("should put a success action when a response is returned", () => {
+    expect(() => {
+      testSaga(updateRemediationSaga, { payload })
+        .next()
+        .put(updateRemediation.request(remediation))
+        .next()
+        .call(apiJsonPut, url, requestData, JSON_OPTS)
+        .next({ data: remediation })
+        .put(updateRemediation.success({ ...payload, ...remediation }))
+        .next()
+        .put(updateRemediation.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(updateRemediationSaga, { payload })
+        .next()
+        .put(updateRemediation.request(remediation))
+        .next()
+        .call(apiJsonPut, url, requestData, JSON_OPTS)
+        .throw(error)
+        .put(updateRemediation.failure(message))
+        .next()
+        .put(updateRemediation.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

package/src/sagas/createRemediation.js

@@ -0,0 +1,31 @@
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import { compile } from "path-to-regexp";
+import { createRemediation, fetchRuleImplementation } from "../routines";
+import { API_REMEDIATION_PLAN } from "../api";
+
+export function* createRemediationSaga({ payload }) {
+  const { remediation, implementation_id, rule_result_id } = payload;
+  try {
+    const requestData = { remediation };
+    const url = compile(API_REMEDIATION_PLAN)({ rule_result_id });
+    yield put(createRemediation.request(remediation));
+    const { data } = yield call(apiJsonPost, url, requestData, JSON_OPTS);
+    yield put(createRemediation.success({ ...payload, ...data }));
+    // Reload rule implementation so that it shows updated remediation icon
+    yield put(fetchRuleImplementation({ id: implementation_id }));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(createRemediation.failure({ status, data }));
+    } else {
+      yield put(createRemediation.failure(error.message));
+    }
+  } finally {
+    yield put(createRemediation.fulfill());
+  }
+}
+
+export function* createRemediationRequestSaga() {
+  yield takeLatest(createRemediation.TRIGGER, createRemediationSaga);
+}

package/src/sagas/deleteRemediation.js

@@ -0,0 +1,29 @@
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJsonDelete, JSON_OPTS } from "@truedat/core/services/api";
+import { compile } from "path-to-regexp";
+import { deleteRemediation, fetchRuleImplementation } from "../routines";
+import { API_REMEDIATION_PLAN } from "../api";
+
+export function* deleteRemediationSaga({ payload }) {
+  try {
+    const { remediation, implementation_id, rule_result_id } = payload;
+    const url = compile(API_REMEDIATION_PLAN)({ rule_result_id });
+    yield put(deleteRemediation.request(remediation));
+    const { data } = yield call(apiJsonDelete, url, JSON_OPTS);
+    yield put(deleteRemediation.success({ ...payload, ...data }));
+    yield put(fetchRuleImplementation({ id: implementation_id }));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(deleteRemediation.failure({ status, data }));
+    } else {
+      yield put(deleteRemediation.failure(error.message));
+    }
+  } finally {
+    yield put(deleteRemediation.fulfill());
+  }
+}
+
+export function* deleteRemediationRequestSaga() {
+  yield takeLatest(deleteRemediation.TRIGGER, deleteRemediationSaga);
+}

package/src/sagas/fetchRemediation.js

@@ -0,0 +1,30 @@
+import { compile } from "path-to-regexp";
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import { fetchRemediation } from "../routines";
+import { API_REMEDIATION_PLAN } from "../api";
+
+export function* fetchRemediationSaga({ payload }) {
+  try {
+    const { rule_result_id } = payload;
+    const url = compile(API_REMEDIATION_PLAN)({
+      rule_result_id,
+    });
+    yield put(fetchRemediation.request());
+    const { data } = yield call(apiJson, url, JSON_OPTS);
+    yield put(fetchRemediation.success(data));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchRemediation.failure({ status, data }));
+    } else {
+      yield put(fetchRemediation.failure(error.message));
+    }
+  } finally {
+    yield put(fetchRemediation.fulfill());
+  }
+}
+
+export function* fetchRemediationRequestSaga() {
+  yield takeLatest(fetchRemediation.TRIGGER, fetchRemediationSaga);
+}

package/src/sagas/index.js

@@ -1,12 +1,15 @@
 import { createExecutionGroupRequestSaga } from "./createExecutionGroup";
 import { createRuleImplementationRequestSaga } from "./createRuleImplementation";
+import { createRemediationRequestSaga } from "./createRemediation";
 import { createRuleRequestSaga } from "./createRule";
 import { setRuleImplementationStatusRequestSaga } from "./setRuleImplementationStatus";
+import { deleteRemediationRequestSaga } from "./deleteRemediation";
 import { deleteRuleRequestSaga } from "./deleteRule";
 import { deleteRuleResultRequestSaga } from "./deleteRuleResult";
 import { downloadRuleImplementationsRequestSaga } from "./downloadRuleImplementations";
 import { fetchConceptRulesRequestSaga } from "./fetchConceptRules";
 import { fetchExecutionGroupRequestSaga } from "./fetchExecutionGroup";
+import { fetchRemediationRequestSaga } from "./fetchRemediation";
 import { fetchRuleFiltersRequestSaga } from "./fetchRuleFilters";
 import { fetchRuleImplementationFiltersRequestSaga } from "./fetchRuleImplementationFilters";
 import { fetchRuleImplementationRequestSaga } from "./fetchRuleImplementation";
@@ -14,6 +17,7 @@ import { fetchRuleImplementationsRequestSaga } from "./fetchRuleImplementations"
 import { fetchRuleRequestSaga } from "./fetchRule";
 import { fetchRulesRequestSaga } from "./fetchRules";
 import { searchRuleImplementationsRequestSaga } from "./searchRuleImplementations";
+import { updateRemediationRequestSaga } from "./updateRemediation";
 import { uploadImplementationsRequestsSaga } from "./uploadImplementations";
 import { uploadRulesRequestsSaga } from "./uploadRules";
 import { updateRuleImplementationRequestSaga } from "./updateRuleImplementation";
@@ -22,14 +26,17 @@ import { uploadResultsRequestSaga } from "./uploadResults";
 
 export {
   createExecutionGroupRequestSaga,
+  createRemediationRequestSaga,
   createRuleImplementationRequestSaga,
   createRuleRequestSaga,
   setRuleImplementationStatusRequestSaga,
+  deleteRemediationRequestSaga,
   deleteRuleRequestSaga,
   deleteRuleResultRequestSaga,
   downloadRuleImplementationsRequestSaga,
   fetchConceptRulesRequestSaga,
   fetchExecutionGroupRequestSaga,
+  fetchRemediationRequestSaga,
   fetchRuleFiltersRequestSaga,
   fetchRuleImplementationFiltersRequestSaga,
   fetchRuleImplementationRequestSaga,
@@ -37,6 +44,7 @@ export {
   fetchRuleRequestSaga,
   fetchRulesRequestSaga,
   searchRuleImplementationsRequestSaga,
+  updateRemediationRequestSaga,
   uploadRulesRequestsSaga,
   uploadImplementationsRequestsSaga,
   updateRuleImplementationRequestSaga,
@@ -46,14 +54,17 @@ export {
 
 export default [
   createExecutionGroupRequestSaga(),
+  createRemediationRequestSaga(),
   createRuleImplementationRequestSaga(),
   createRuleRequestSaga(),
   setRuleImplementationStatusRequestSaga(),
+  deleteRemediationRequestSaga(),
   deleteRuleRequestSaga(),
   deleteRuleResultRequestSaga(),
   downloadRuleImplementationsRequestSaga(),
   fetchConceptRulesRequestSaga(),
   fetchExecutionGroupRequestSaga(),
+  fetchRemediationRequestSaga(),
   fetchRuleFiltersRequestSaga(),
   fetchRuleImplementationFiltersRequestSaga(),
   fetchRuleImplementationRequestSaga(),
@@ -61,6 +72,7 @@ export default [
   fetchRuleRequestSaga(),
   fetchRulesRequestSaga(),
   searchRuleImplementationsRequestSaga(),
+  updateRemediationRequestSaga(),
   uploadRulesRequestsSaga(),
   uploadImplementationsRequestsSaga(),
   updateRuleImplementationRequestSaga(),

package/src/sagas/updateRemediation.js

@@ -0,0 +1,29 @@
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJsonPut, JSON_OPTS } from "@truedat/core/services/api";
+import { compile } from "path-to-regexp";
+import { updateRemediation } from "../routines";
+import { API_REMEDIATION_PLAN } from "../api";
+
+export function* updateRemediationSaga({ payload }) {
+  try {
+    const { remediation, rule_result_id } = payload;
+    const requestData = { remediation };
+    const url = compile(API_REMEDIATION_PLAN)({ rule_result_id });
+    yield put(updateRemediation.request(remediation));
+    const { data } = yield call(apiJsonPut, url, requestData, JSON_OPTS);
+    yield put(updateRemediation.success({ ...payload, ...data }));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(updateRemediation.failure({ status, data }));
+    } else {
+      yield put(updateRemediation.failure(error.message));
+    }
+  } finally {
+    yield put(updateRemediation.fulfill());
+  }
+}
+
+export function* updateRemediationRequestSaga() {
+  yield takeLatest(updateRemediation.TRIGGER, updateRemediationSaga);
+}

package/src/styles/executionDetails.less

@@ -0,0 +1,3 @@
+.ui.segment.execution-details-remediation {
+  margin-top: 1rem;
+}

package/src/styles/remediationPlan.less

@@ -0,0 +1,8 @@
+.ui.button.button-edit-remediation {
+  float: right;
+  margin-left: 5px;
+}
+
+.ui.actions.remediation {
+  float: right;
+}