@truedat/dd 4.36.9 → 4.37.3

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

@@ -1,39 +1,39 @@
 import _ from "lodash/fp";
 import { accentInsensitivePathOrder } from "@truedat/core/services/sort";
-import { initialState } from "../structureUserFilters";
+import { initialState } from "../userSearchFilters";
 import {
-  fetchStructureUserFilters,
-  clearStructureUserFilters,
-  deleteStructureUserFilter,
-  saveStructureUserFilters
+  fetchUserSearchFilters,
+  clearUserSearchFilters,
+  deleteUserSearchFilter,
+  saveUserSearchFilters,
 } from "../../routines";
-import { structureUserFilters } from "..";
+import { userSearchFilters } from "..";
 
 const fooState = { foo: "bar" };
 
 describe("reducers: structureActiveFilters", () => {
   it("should provide the initial state", () => {
-    expect(structureUserFilters(undefined, {})).toEqual(initialState);
+    expect(userSearchFilters(undefined, {})).toEqual(initialState);
   });
 
-  it("should handle the fetchStructureUserFilters.SUCCESS action", () => {
+  it("should handle the fetchUserSearchFilters.SUCCESS action", () => {
     const filters = [
       { name: "b", id: 1, filters: { country: ["S"] } },
-      { name: "a", id: 2, filters: { country: ["S2"] } }
+      { name: "a", id: 2, filters: { country: ["S2"] } },
     ];
     const sortedFilters = _.sortBy(accentInsensitivePathOrder("name"))(filters);
     expect(
-      structureUserFilters(fooState, {
-        type: fetchStructureUserFilters.SUCCESS,
-        payload: { data: filters }
+      userSearchFilters(fooState, {
+        type: fetchUserSearchFilters.SUCCESS,
+        payload: { data: filters },
       })
     ).toEqual(sortedFilters);
   });
 
-  it("should handle the saveStructureUserFilters.SUCCESS action", () => {
+  it("should handle the saveUserSearchFilters.SUCCESS action", () => {
     const filters = [
       { name: "b", id: 1, filters: { country: ["S"] } },
-      { name: "a", id: 2, filters: { country: ["S2"] } }
+      { name: "a", id: 2, filters: { country: ["S2"] } },
     ];
     const newFilter = { name: "c", id: 3, filters: { country: ["S3"] } };
     const sortedFilters = _.flow(
@@ -42,35 +42,35 @@ describe("reducers: structureActiveFilters", () => {
     )(filters);
 
     expect(
-      structureUserFilters(filters, {
-        type: saveStructureUserFilters.SUCCESS,
-        payload: { data: newFilter }
+      userSearchFilters(filters, {
+        type: saveUserSearchFilters.SUCCESS,
+        payload: { data: newFilter },
       })
     ).toEqual(sortedFilters);
   });
 
-  it("should handle the deleteStructureUserFilter.SUCCESS action", () => {
+  it("should handle the deleteUserSearchFilter.SUCCESS action", () => {
     const filters = [
       { name: "b", id: 1, filters: { country: ["S"] } },
-      { name: "a", id: 2, filters: { country: ["S2"] } }
+      { name: "a", id: 2, filters: { country: ["S2"] } },
     ];
     expect(
-      structureUserFilters(filters, {
-        type: deleteStructureUserFilter.SUCCESS,
-        meta: { id: 1 }
+      userSearchFilters(filters, {
+        type: deleteUserSearchFilter.SUCCESS,
+        meta: { id: 1 },
       })
     ).toEqual([{ name: "a", id: 2, filters: { country: ["S2"] } }]);
   });
 
-  it("should handle the clearStructureUserFilters.TRIGGER action", () => {
+  it("should handle the clearUserSearchFilters.TRIGGER action", () => {
     expect(
-      structureUserFilters(fooState, {
-        type: clearStructureUserFilters.TRIGGER
+      userSearchFilters(fooState, {
+        type: clearUserSearchFilters.TRIGGER,
       })
     ).toEqual(initialState);
   });
 
   it("should ignore unknown actions", () => {
-    expect(structureUserFilters(fooState, { type: "FOO" })).toBe(fooState);
+    expect(userSearchFilters(fooState, { type: "FOO" })).toBe(fooState);
   });
 });

package/src/reducers/index.js

@@ -59,7 +59,7 @@ import { structureProfile } from "./structureProfile";
 import { structureQuery } from "./structureQuery";
 import { structureRedirect } from "./structureRedirect";
 import { structureSelectedFilter } from "./structureSelectedFilter";
-import { structureSelectedUserFilter } from "./structureSelectedUserFilter";
+import { selectedUserSearchFilter } from "./selectedUserSearchFilter";
 import { structureSiblings } from "./structureSiblings";
 import { structuresSiblings } from "./structureSiblings";
 import { structureSystem } from "./structureSystem";
@@ -72,7 +72,7 @@ import { structureTypeLoading } from "./structureTypeLoading";
 import { structureTypes } from "./structureTypes";
 import { structureTypesLoading } from "./structureTypesLoading";
 import { structureUpdating } from "./structureUpdating";
-import { structureUserFilters } from "./structureUserFilters";
+import { userSearchFilters } from "./userSearchFilters";
 import { structureVersion } from "./structureVersion";
 import { structureVersions } from "./structureVersions";
 import { structures } from "./structures";
@@ -155,7 +155,7 @@ export {
   structureQuery,
   structureRedirect,
   structureSelectedFilter,
-  structureSelectedUserFilter,
+  selectedUserSearchFilter,
   structureSiblings,
   structureSystem,
   structuresSiblings,
@@ -169,7 +169,7 @@ export {
   structureTypes,
   structureTypesLoading,
   structureUpdating,
-  structureUserFilters,
+  userSearchFilters,
   structureVersion,
   structureVersions,
   structures,

package/src/reducers/selectedUserSearchFilter.js

@@ -0,0 +1,48 @@
+import {
+  clearRuleFilters,
+  resetRuleFilters,
+  clearImplementationFilters,
+  resetImplementationFilters,
+} from "@truedat/dq/routines";
+import {
+  applyUserSearchFilter,
+  clearUserSearchFilters,
+  removeStructureFilter,
+  resetStructureFilters,
+} from "../routines";
+
+/** @type {string} */
+export const initialState = null;
+
+export const selectedUserSearchFilter = (
+  state = initialState,
+  { type, payload }
+) => {
+  switch (type) {
+    case applyUserSearchFilter.TRIGGER:
+      const {
+        userFilter: { name: name },
+      } = payload;
+      if (state == name) {
+        return initialState;
+      } else {
+        return name;
+      }
+    case clearUserSearchFilters.TRIGGER:
+      return initialState;
+    case removeStructureFilter.TRIGGER:
+      return initialState;
+    case resetStructureFilters.TRIGGER:
+      return initialState;
+    case clearRuleFilters.TRIGGER:
+      return initialState;
+    case resetRuleFilters.TRIGGER:
+      return initialState;
+    case clearImplementationFilters.TRIGGER:
+      return initialState;
+    case resetImplementationFilters.TRIGGER:
+      return initialState;
+    default:
+      return state;
+  }
+};

package/src/reducers/structureActiveFilters.js

@@ -10,7 +10,7 @@ import {
 } from "lodash/fp";
 import {
   addStructureFilter,
-  applyStructureUserFilter,
+  applyUserSearchFilter,
   clearStructureFilters,
   closeStructureFilter,
   removeStructureFilter,
@@ -31,9 +31,9 @@ export const structureActiveFilters = (
       const { filter } = payload;
       return { ...state, [filter]: [] };
     }
-    case applyStructureUserFilter.TRIGGER: {
-      const { userFilter } = payload;
-      return prop("filters")(userFilter);
+    case applyUserSearchFilter.TRIGGER: {
+      const { userFilter, scope } = payload;
+      return scope === "data_structure" ? prop("filters")(userFilter) : state;
     }
     case closeStructureFilter.TRIGGER: {
       const { filter } = payload;

package/src/reducers/structureQuery.js

@@ -1,6 +1,6 @@
 import _ from "lodash/fp";
 import {
-  applyStructureUserFilter,
+  applyUserSearchFilter,
   clearStructureFilters,
   removeStructureFilter,
   searchStructures,
@@ -31,7 +31,7 @@ const structureQuery = (state = initialState, { type, payload }) => {
       const page = defaultPage;
       return { ...state, page };
     }
-    case applyStructureUserFilter.TRIGGER: {
+    case applyUserSearchFilter.TRIGGER: {
       const page = defaultPage;
       return { ...state, page };
     }

package/src/reducers/{structureUserFilters.js → userSearchFilters.js}

@@ -1,34 +1,31 @@
 import _ from "lodash/fp";
 import { accentInsensitivePathOrder } from "@truedat/core/services/sort";
 import {
-  fetchStructureUserFilters,
-  clearStructureUserFilters,
-  deleteStructureUserFilter,
-  saveStructureUserFilters
+  fetchUserSearchFilters,
+  clearUserSearchFilters,
+  deleteUserSearchFilter,
+  saveUserSearchFilters,
 } from "../routines";
 
 export const initialState = [];
 
-const structureUserFilters = (
-  state = initialState,
-  { type, payload, meta }
-) => {
+const userSearchFilters = (state = initialState, { type, payload, meta }) => {
   switch (type) {
-    case clearStructureUserFilters.TRIGGER:
+    case clearUserSearchFilters.TRIGGER:
       return initialState;
-    case fetchStructureUserFilters.SUCCESS: {
+    case fetchUserSearchFilters.SUCCESS: {
       const userFilters = _.propOr([], "data")(payload);
       return _.sortBy(accentInsensitivePathOrder("name"))(userFilters);
     }
-    case fetchStructureUserFilters.FAILURE:
+    case fetchUserSearchFilters.FAILURE:
       return initialState;
-    case saveStructureUserFilters.SUCCESS:
+    case saveUserSearchFilters.SUCCESS:
       const userFilter = _.propOr({}, "data")(payload);
       return _.flow(
         _.concat([userFilter]),
         _.sortBy(accentInsensitivePathOrder("name"))
       )(state);
-    case deleteStructureUserFilter.SUCCESS:
+    case deleteUserSearchFilter.SUCCESS:
       const { id } = meta;
       return _.reject(_.propEq("id", id))(state);
     default:
@@ -36,4 +33,4 @@ const structureUserFilters = (
   }
 };
 
-export { structureUserFilters };
+export { userSearchFilters };

package/src/routines.js

@@ -9,9 +9,7 @@ export const applyGrantDateFilter = createRoutine("APPLY_GRANT_DATE_FILTER");
 export const applyStructureDateFilter = createRoutine(
   "APPLY_STRUCTURE_DATE_FILTER"
 );
-export const applyStructureUserFilter = createRoutine(
-  "APPLY_STRUCTURE_USER_FILTER"
-);
+export const applyUserSearchFilter = createRoutine("APPLY_USER_SEARCH_FILTER");
 export const bulkUpdateStructures = createRoutine("BULK_UPDATE_STRUCTURES");
 export const cancelPoll = createRoutine("CANCEL_POLL");
 export const clearGrantFilters = createRoutine("CLEAR_GRANT_FILTERS");
@@ -32,8 +30,8 @@ export const clearStructureTag = createRoutine("CLEAR_STRUCTURE_TAG");
 export const clearStructureTags = createRoutine("CLEAR_STRUCTURE_TAGS");
 export const clearStructureType = createRoutine("CLEAR_STRUCTURE_TYPE");
 export const clearStructureTypes = createRoutine("CLEAR_STRUCTURE_TYPES");
-export const clearStructureUserFilters = createRoutine(
-  "CLEAR_STRUCTURE_USER_FILTERS"
+export const clearUserSearchFilters = createRoutine(
+  "CLEAR_USER_SEARCH_FILTERS"
 );
 export const clearStructures = createRoutine("CLEAR_STRUCTURES");
 export const clearStructuresSort = createRoutine("CLEAR_STRUCTURES_SORT");
@@ -53,8 +51,8 @@ export const deleteLinkStructureTag = createRoutine(
   "DELETE_LINK_STRUCTURE_TAG"
 );
 export const deleteStructureTag = createRoutine("DELETE_STRUCTURE_TAG");
-export const deleteStructureUserFilter = createRoutine(
-  "DELETE_STRUCTURE_USER_FILTER"
+export const deleteUserSearchFilter = createRoutine(
+  "DELETE_USER_SEARCH_FILTER"
 );
 export const doStructureNoteAction = createRoutine("DO_STRUCTURE_NOTE_ACTION");
 export const downloadCsvGraph = createRoutine("DOWNLOAD_CSV_GRAPH");
@@ -84,8 +82,8 @@ export const fetchStructureTag = createRoutine("FETCH_STRUCTURE_TAG");
 export const fetchStructureTags = createRoutine("FETCH_STRUCTURE_TAGS");
 export const fetchStructureType = createRoutine("FETCH_STRUCTURE_TYPE");
 export const fetchStructureTypes = createRoutine("FETCH_STRUCTURE_TYPES");
-export const fetchStructureUserFilters = createRoutine(
-  "FETCH_STRUCTURE_USER_FILTERS"
+export const fetchUserSearchFilters = createRoutine(
+  "FETCH_USER_SEARCH_FILTERS"
 );
 export const fetchStructures = createRoutine("FETCH_STRUCTURES");
 export const fetchSystem = createRoutine("FETCH_SYSTEM");
@@ -106,9 +104,7 @@ export const removeStructureSelectedFilter = createRoutine(
 );
 export const resetGrantFilters = createRoutine("RESET_GRANT_FILTERS");
 export const resetStructureFilters = createRoutine("RESET_STRUCTURE_FILTERS");
-export const saveStructureUserFilters = createRoutine(
-  "SAVE_STRUCTURE_USER_FILTERS"
-);
+export const saveUserSearchFilters = createRoutine("SAVE_USER_SEARCH_FILTERS");
 export const searchGrants = createRoutine("SEARCH_GRANTS");
 export const searchStructures = createRoutine("SEARCH_STRUCTURES");
 export const selectGrantPage = createRoutine("SELECT_GRANT_PAGE");

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

@@ -0,0 +1,72 @@
+import { compile } from "path-to-regexp";
+import { testSaga } from "redux-saga-test-plan";
+import { apiJsonDelete, JSON_OPTS } from "@truedat/core/services/api";
+import {
+  deleteUserSearchFilterSaga,
+  deleteUserSearchFilterRequestSaga,
+} from "../deleteUserSearchFilter";
+import { deleteUserSearchFilter } from "../../routines";
+import { API_USER_SEARCH_FILTER } from "../../api";
+
+describe("sagas: deleteUserSearchFilterRequestSaga", () => {
+  it("should invoke deleteUserSearchFilterSaga on deleteUserSearchFilter.TRIGGER", () => {
+    expect(() => {
+      testSaga(deleteUserSearchFilterRequestSaga)
+        .next()
+        .takeLatest(deleteUserSearchFilter.TRIGGER, deleteUserSearchFilterSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(deleteUserSearchFilterRequestSaga)
+        .next()
+        .takeLatest("FOO", deleteUserSearchFilterRequestSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: deleteUserSearchFilterSaga", () => {
+  const payload = { id: 1 };
+  const { id } = payload;
+  const url = compile(API_USER_SEARCH_FILTER)({ id });
+  const meta = { id };
+
+  it("should put a success action when a response is returned", () => {
+    expect(() => {
+      testSaga(deleteUserSearchFilterSaga, { payload })
+        .next()
+        .put({ meta, ...deleteUserSearchFilter.request() })
+        .next()
+        .call(apiJsonDelete, url, JSON_OPTS)
+        .next({ data: payload })
+        .put({ meta, ...deleteUserSearchFilter.success(payload) })
+        .next()
+        .put(deleteUserSearchFilter.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 meta = { id: 1 };
+
+    expect(() => {
+      testSaga(deleteUserSearchFilterSaga, { payload })
+        .next()
+        .put({ meta, ...deleteUserSearchFilter.request() })
+        .next()
+        .call(apiJsonDelete, url, JSON_OPTS)
+        .throw(error)
+        .put(deleteUserSearchFilter.failure(message))
+        .next()
+        .put(deleteUserSearchFilter.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,69 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import {
+  fetchUserSearchFiltersRequestSaga,
+  fetchUserSearchFiltersSaga,
+} from "../fetchUserSearchFilters";
+import { fetchUserSearchFilters } from "../../routines";
+import { API_GET_USER_SEARCH_FILTERS } from "../../api";
+
+describe("sagas: fetchUserSearchFiltersRequestSaga", () => {
+  it("should invoke fetchUserSearchFiltersSaga on fetchUserSearchFilters.TRIGGER", () => {
+    expect(() => {
+      testSaga(fetchUserSearchFiltersRequestSaga)
+        .next()
+        .takeLatest(fetchUserSearchFilters.TRIGGER, fetchUserSearchFiltersSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(fetchUserSearchFiltersRequestSaga)
+        .next()
+        .takeLatest("FOO", fetchUserSearchFiltersRequestSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: fetchUserSearchFiltersSaga", () => {
+  const data = [{ id: 1, name: "a" }];
+  const payload = "test_scope";
+  const url = `${API_GET_USER_SEARCH_FILTERS}?scope=${payload}`;
+
+  it("should put a success action when a response is returned", () => {
+    expect(() => {
+      testSaga(fetchUserSearchFiltersSaga, { payload })
+        .next()
+        .put(fetchUserSearchFilters.request())
+        .next()
+        .call(apiJson, url, JSON_OPTS)
+        .next({ data })
+        .put(fetchUserSearchFilters.success(data))
+        .next()
+        .put(fetchUserSearchFilters.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(fetchUserSearchFiltersSaga, { payload })
+        .next()
+        .put(fetchUserSearchFilters.request())
+        .next()
+        .call(apiJson, url, JSON_OPTS)
+        .throw(error)
+        .put(fetchUserSearchFilters.failure(message))
+        .next()
+        .put(fetchUserSearchFilters.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,78 @@
+import { testSaga } from "redux-saga-test-plan";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import {
+  saveUserSearchFiltersRequestSaga,
+  saveUserSearchFiltersSaga,
+} from "../saveUserSearchFilters";
+import { saveUserSearchFilters } from "../../routines";
+import { API_USER_SEARCH_FILTERS } from "../../api";
+
+describe("sagas: saveStructureFiltersRequestSaga", () => {
+  it("should invoke saveStructureFiltersSaga on saveStructureFilters.TRIGGER", () => {
+    expect(() => {
+      testSaga(saveUserSearchFiltersRequestSaga)
+        .next()
+        .takeLatest(saveUserSearchFilters.TRIGGER, saveUserSearchFiltersSaga)
+        .finish()
+        .isDone();
+    }).not.toThrow();
+  });
+
+  it("should throw exception if an unhandled action is received", () => {
+    expect(() => {
+      testSaga(saveUserSearchFiltersRequestSaga)
+        .next()
+        .takeLatest("FOO", saveUserSearchFiltersRequestSaga);
+    }).toThrow();
+  });
+});
+
+describe("sagas: saveStructureFiltersSaga", () => {
+  const data = { user_search_filter: { id: 1, name: "a" } };
+  const payload = {
+    filterName: "a",
+    filters: { country: ["A"] },
+    scope: "data_structure",
+  };
+  const requestData = {
+    user_search_filter: {
+      name: "a",
+      filters: { country: ["A"] },
+      scope: "data_structure",
+    },
+  };
+  it("should put a success action when a response is returned", () => {
+    expect(() => {
+      testSaga(saveUserSearchFiltersSaga, { payload })
+        .next()
+        .put(saveUserSearchFilters.request())
+        .next()
+        .call(apiJsonPost, API_USER_SEARCH_FILTERS, requestData, JSON_OPTS)
+        .next({ data })
+        .put(saveUserSearchFilters.success(data))
+        .next()
+        .put(saveUserSearchFilters.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(saveUserSearchFiltersSaga, { payload })
+        .next()
+        .put(saveUserSearchFilters.request())
+        .next()
+        .call(apiJsonPost, API_USER_SEARCH_FILTERS, requestData, JSON_OPTS)
+        .throw(error)
+        .put(saveUserSearchFilters.failure(message))
+        .next()
+        .put(saveUserSearchFilters.fulfill())
+        .next()
+        .isDone();
+    }).not.toThrow();
+  });
+});

package/src/sagas/deleteUserSearchFilter.js

@@ -0,0 +1,31 @@
+import { compile } from "path-to-regexp";
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJsonDelete, JSON_OPTS } from "@truedat/core/services/api";
+import { deleteUserSearchFilter } from "../routines";
+import { API_USER_SEARCH_FILTER } from "../api";
+
+const toApiPath = compile(API_USER_SEARCH_FILTER);
+
+export function* deleteUserSearchFilterSaga({ payload }) {
+  try {
+    const url = toApiPath(payload);
+    const { id } = payload;
+    const meta = { id };
+    yield put({ meta, ...deleteUserSearchFilter.request() });
+    const { data } = yield call(apiJsonDelete, url, JSON_OPTS);
+    yield put({ meta, ...deleteUserSearchFilter.success(data) });
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(deleteUserSearchFilter.failure({ status, data }));
+    } else {
+      yield put(deleteUserSearchFilter.failure(error.message));
+    }
+  } finally {
+    yield put(deleteUserSearchFilter.fulfill());
+  }
+}
+
+export function* deleteUserSearchFilterRequestSaga() {
+  yield takeLatest(deleteUserSearchFilter.TRIGGER, deleteUserSearchFilterSaga);
+}

package/src/sagas/fetchUserSearchFilters.js

@@ -0,0 +1,26 @@
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJson, JSON_OPTS } from "@truedat/core/services/api";
+import { fetchUserSearchFilters } from "../routines";
+import { API_GET_USER_SEARCH_FILTERS } from "../api";
+
+export function* fetchUserSearchFiltersSaga({ payload }) {
+  try {
+    const url = `${API_GET_USER_SEARCH_FILTERS}?scope=${payload}`;
+    yield put(fetchUserSearchFilters.request());
+    const { data } = yield call(apiJson, url, JSON_OPTS);
+    yield put(fetchUserSearchFilters.success(data));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchUserSearchFilters.failure({ status, data }));
+    } else {
+      yield put(fetchUserSearchFilters.failure(error.message));
+    }
+  } finally {
+    yield put(fetchUserSearchFilters.fulfill());
+  }
+}
+
+export function* fetchUserSearchFiltersRequestSaga() {
+  yield takeLatest(fetchUserSearchFilters.TRIGGER, fetchUserSearchFiltersSaga);
+}