@truedat/dd 4.28.1 → 4.28.5

package/src/sagas/fetchGrantFilters.js

@@ -0,0 +1,29 @@
+import _ from "lodash/fp";
+import { call, put, takeLatest } from "redux-saga/effects";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import { fetchGrantFilters } from "../routines";
+import { API_GRANT_FILTERS_SEARCH } from "../api";
+
+export function* fetchGrantFiltersSaga(payload) {
+  try {
+    yield put(fetchGrantFilters.request());
+    const url = API_GRANT_FILTERS_SEARCH;
+    const filters = _.propOr({}, "payload.filters")(payload);
+    const body = { filters };
+    const { data } = yield call(apiJsonPost, url, body, JSON_OPTS);
+    yield put(fetchGrantFilters.success({ data }));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchGrantFilters.failure({ status, data }));
+    } else {
+      yield put(fetchGrantFilters.failure(error.message));
+    }
+  } finally {
+    yield put(fetchGrantFilters.fulfill());
+  }
+}
+
+export function* fetchGrantFiltersRequestSaga() {
+  yield takeLatest(fetchGrantFilters.TRIGGER, fetchGrantFiltersSaga);
+}

package/src/sagas/fetchGrants.js

@@ -0,0 +1,26 @@
+import { call, put, debounce } from "redux-saga/effects";
+import { apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import { fetchGrants } from "../routines";
+import { API_GRANTS_SEARCH } from "../api";
+
+export function* fetchGrantsSaga({ payload: body }) {
+  try {
+    const url = API_GRANTS_SEARCH;
+    yield put(fetchGrants.request(body));
+    const { data, headers } = yield call(apiJsonPost, url, body, JSON_OPTS);
+    yield put(fetchGrants.success({ data, headers }));
+  } catch (error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      yield put(fetchGrants.failure({ status, data }));
+    } else {
+      yield put(fetchGrants.failure(error.message));
+    }
+  } finally {
+    yield put(fetchGrants.fulfill());
+  }
+}
+
+export function* fetchGrantsRequestSaga() {
+  yield debounce(200, fetchGrants.TRIGGER, fetchGrantsSaga);
+}

package/src/sagas/index.js

@@ -11,6 +11,8 @@ import { deleteStructureUserFilterRequestSaga } from "./deleteStructureUserFilte
 import { doStructureNoteActionRequestSaga } from "./doStructureNoteAction";
 import { downloadCsvGraphRequestSaga } from "./downloadCsvGraph";
 import { downloadStructuresRequestSaga } from "./downloadStructures";
+import { fetchGrantFiltersRequestSaga } from "./fetchGrantFilters";
+import { fetchGrantsRequestSaga } from "./fetchGrants";
 import { fetchGraphRequestSaga } from "./fetchGraph";
 import { fetchLinksStructureTagsRequestSaga } from "./fetchLinksStructureTags";
 import { fetchNodesRequestSaga } from "./fetchNodes";
@@ -53,6 +55,8 @@ export {
   doStructureNoteActionRequestSaga,
   downloadCsvGraphRequestSaga,
   downloadStructuresRequestSaga,
+  fetchGrantFiltersRequestSaga,
+  fetchGrantsRequestSaga,
   fetchGraphRequestSaga,
   fetchLinksStructureTagsRequestSaga,
   fetchNodesRequestSaga,
@@ -96,6 +100,8 @@ export default [
   doStructureNoteActionRequestSaga(),
   downloadCsvGraphRequestSaga(),
   downloadStructuresRequestSaga(),
+  fetchGrantFiltersRequestSaga(),
+  fetchGrantsRequestSaga(),
   fetchGraphRequestSaga(),
   fetchLinksStructureTagsRequestSaga(),
   fetchNodesRequestSaga(),

package/src/selectors/__tests__/__snapshots__/getGrantsColumns.spec.js.snap

@@ -42,6 +42,16 @@ exports[`GrantStructureDecorator matches the latest snapshot when structure is n
 </div>
 `;
 
+exports[`GrantTableStructureDecorator matches the latest snapshot when structure is direct 1`] = `
+<div>
+  <a
+    href="/structures/1"
+  >
+    foo
+  </a>
+</div>
+`;
+
 exports[`GrantUserDecorator matches the latest snapshot 1`] = `
 <div>
   <h4

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

@@ -0,0 +1,15 @@
+import { getGrantAvailableFilters } from "..";
+
+const foo = ["foo1", "foo2"];
+const bar = ["bar1", "bar2"];
+const baz = ["baz1", "baz2"];
+
+describe("selectors: getGrantAvailableFilters", () => {
+  const grantFilters = { foo, bar, baz };
+  const grantActiveFilters = { baz: [] };
+  const state = { grantFilters, grantActiveFilters };
+
+  it("should return the keys of the grant filters which are not currently active", () => {
+    expect(getGrantAvailableFilters(state)).toEqual(["foo", "bar"]);
+  });
+});

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

@@ -0,0 +1,16 @@
+import { getGrantSelectedFilterActiveValues } from "..";
+
+const foo = ["foo1", "foo2"];
+const bar = ["bar1", "bar2"];
+const baz = ["baz1", "baz2"];
+
+describe("selectors: getGrantSelectedFilterActiveValues", () => {
+  const grantFilters = { foo, bar, baz };
+  const grantActiveFilters = { foo: ["foo1"] };
+  const grantSelectedFilter = "foo";
+  const state = { grantFilters, grantActiveFilters, grantSelectedFilter };
+
+  it("should return the active values of the currently selected grant filters", () => {
+    expect(getGrantSelectedFilterActiveValues(state)).toEqual(["foo1"]);
+  });
+});

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

@@ -0,0 +1,15 @@
+import { getGrantSelectedFilterValues } from "..";
+
+const foo = ["foo1", "foo2"];
+const bar = ["bar1", "bar2"];
+const baz = ["baz1", "baz2"];
+
+describe("selectors: getGrantSelectedFilterValues", () => {
+  const grantFilters = { foo, bar, baz };
+  const grantSelectedFilter = "foo";
+  const state = { grantFilters, grantSelectedFilter };
+
+  it("should return the values of the currently selected grant filters", () => {
+    expect(getGrantSelectedFilterValues(state)).toEqual(foo);
+  });
+});

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

@@ -0,0 +1,15 @@
+import { getGrantSelectedFilters } from "..";
+
+const foo = ["foo1", "foo2"];
+const bar = ["bar1", "bar2"];
+const baz = ["baz1", "baz2"];
+
+describe("selectors: getStructureAvailableFilters", () => {
+  const grantFilters = { foo, bar, baz };
+  const grantActiveFilters = { baz: [] };
+  const state = { grantFilters, grantActiveFilters };
+
+  it("should return the keys of the grant filters which are currently active", () => {
+    expect(getGrantSelectedFilters(state)).toEqual(["baz"]);
+  });
+});

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

@@ -3,9 +3,12 @@ import React from "react";
 import { render } from "@truedat/test/render";
 import {
   defaultGrantsColumns,
+  defaultGrantsTableColumns,
   getGrantsColumns,
+  getGrantsTableColumns,
   GrantUserDecorator,
   GrantStructureDecorator,
+  GrantTableStructureDecorator,
   StartDateDecorator,
   EndDateDecorator,
 } from "..";
@@ -49,6 +52,30 @@ describe("selectors: getGrantsColumns", () => {
   });
 });
 
+describe("selectors: getGrantsTableColumns", () => {
+  const state = {
+    authentication,
+  };
+
+  it("get default grant columns", () => {
+    const columns = getGrantsTableColumns(state);
+    expect(_.map("name")(columns)).toEqual(
+      _.map("name")(defaultGrantsTableColumns)
+    );
+  });
+
+  it("get specified columns in reducer", () => {
+    const grantsColumns = [
+      {
+        name: "foo",
+        fieldDecorator: _.identity,
+      },
+    ];
+    const columns = getGrantsTableColumns({ ...state, grantsColumns });
+    expect(columns).toStrictEqual(grantsColumns);
+  });
+});
+
 describe("GrantUserDecorator", () => {
   it("matches the latest snapshot", () => {
     const props = {
@@ -91,6 +118,19 @@ describe("GrantStructureDecorator", () => {
   });
 });
 
+describe("GrantTableStructureDecorator", () => {
+  it("matches the latest snapshot when structure is direct", () => {
+    const props = {
+      data_structure_version: { data_structure_id: 1, name: "foo" },
+    };
+    const { container } = render(
+      <GrantTableStructureDecorator {...props} />,
+      renderOpts
+    );
+    expect(container).toMatchSnapshot();
+  });
+});
+
 describe("StartDateDecorator", () => {
   it("matches the latest snapshot", () => {
     const props = {

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

@@ -3,10 +3,10 @@ import { getTabVisibility } from "../getTabVisibility";
 describe("selectors: getTabVisibility", () => {
   it("should include fields iff structureFields is not empty", () => {
     expect(getTabVisibility({ structureFields: [1] })).toMatchObject({
-      fields: true
+      fields: true,
     });
     expect(getTabVisibility({ structureFields: [] })).toMatchObject({
-      fields: false
+      fields: false,
     });
   });
 
@@ -32,7 +32,7 @@ describe("selectors: getTabVisibility", () => {
     const structureFields = [{ profile: { foo: "foo" } }];
     const userPermissions = { view_profiling_permission: true };
     expect(getTabVisibility({ structureFields })).toMatchObject({
-      profile: false
+      profile: false,
     });
     expect(
       getTabVisibility({ structureFields, userPermissions })
@@ -42,44 +42,44 @@ describe("selectors: getTabVisibility", () => {
   it("should include profile if permission is present and a structure has a profile", () => {
     const userPermissions = { view_profiling_permission: true };
     expect(getTabVisibility({ structure: {} })).toMatchObject({
-      profile: false
+      profile: false,
     });
     expect(
       getTabVisibility({
         structure: { profile: { foo: "foo" } },
-        userPermissions
+        userPermissions,
       })
     ).toMatchObject({ profile: false });
     expect(
       getTabVisibility({
         structureProfile: { patterns: "foo" },
-        userPermissions
+        userPermissions,
       })
     ).toMatchObject({ profile: true });
     expect(
       getTabVisibility({
         structureProfile: { most_frequent: "foo" },
-        userPermissions
+        userPermissions,
       })
     ).toMatchObject({ profile: true });
   });
 
   it("should include links iff conceptCount is non-zero or structure has links", () => {
     expect(getTabVisibility({ conceptCount: 1 })).toMatchObject({
-      links: true
+      links: true,
     });
     expect(getTabVisibility({ conceptCount: 0 })).toMatchObject({
-      links: false
+      links: false,
     });
     expect(
       getTabVisibility({ structureLinks: [{ resource_type: "concept" }] })
     ).toMatchObject({
-      links: true
+      links: true,
     });
     expect(
       getTabVisibility({ structureLinks: [{ resource_type: "foo" }] })
     ).toMatchObject({
-      links: false
+      links: false,
     });
   });
 
@@ -88,17 +88,17 @@ describe("selectors: getTabVisibility", () => {
     const templates = [{ name: "foo" }];
     const structureTypes = [{ name: "foo", template: { id: 1, name: "n" } }];
     expect(getTabVisibility({ templatesLoading: true })).toMatchObject({
-      notes: false
+      notes: false,
     });
     expect(
       getTabVisibility({
         structure,
         templates,
         structureTypes,
-        structureTypesLoading: false
+        structureTypesLoading: false,
       })
     ).toMatchObject({
-      notes: true
+      notes: true,
     });
   });
 
@@ -107,80 +107,80 @@ describe("selectors: getTabVisibility", () => {
     const templates = [{ name: "foo" }];
     const structureTypes = [{ name: "foo" }];
     expect(getTabVisibility({ templatesLoading: true })).toMatchObject({
-      notes: false
+      notes: false,
     });
     expect(
       getTabVisibility({
         structure,
         templates,
         structureTypes,
-        structureTypesLoading: false
+        structureTypesLoading: false,
       })
     ).toMatchObject({
-      notes: false
+      notes: false,
     });
   });
 
   it("should include versions iff structureVersions is not empty", () => {
     expect(getTabVisibility({})).toMatchObject({ versions: false });
     expect(getTabVisibility({ structureVersions: [] })).toMatchObject({
-      versions: false
+      versions: false,
     });
     expect(getTabVisibility({ structureVersions: [{}] })).toMatchObject({
-      versions: true
+      versions: true,
     });
   });
 
   it("should include events iff structureVersion is empty", () => {
     expect(getTabVisibility({})).toMatchObject({ events: true });
     expect(getTabVisibility({ structureVersion: {} })).toMatchObject({
-      events: true
+      events: true,
     });
     expect(getTabVisibility({ structureVersion: "whatever" })).toMatchObject({
-      events: false
+      events: false,
     });
   });
 
   it("should include rules iff ruleImplementations is not empty", () => {
     expect(getTabVisibility({})).toMatchObject({ rules: false });
     expect(getTabVisibility({ ruleImplementations: [] })).toMatchObject({
-      rules: false
+      rules: false,
     });
     expect(getTabVisibility({ ruleImplementations: [{}] })).toMatchObject({
-      rules: true
+      rules: true,
     });
   });
 
   it("should include parents iff parentRelations is not empty", () => {
     expect(getTabVisibility({})).toMatchObject({ parents: false });
     expect(getTabVisibility({ parentRelations: [] })).toMatchObject({
-      parents: false
+      parents: false,
     });
     expect(getTabVisibility({ parentRelations: [{}] })).toMatchObject({
-      parents: true
+      parents: true,
     });
   });
 
   it("should include children iff childrenRelations is not empty", () => {
     expect(getTabVisibility({})).toMatchObject({ children: false });
     expect(getTabVisibility({ childrenRelations: [] })).toMatchObject({
-      children: false
+      children: false,
     });
     expect(getTabVisibility({ childrenRelations: [{}] })).toMatchObject({
-      children: true
+      children: true,
     });
   });
 
   it("should include grants if grants is not empty or nil", () => {
     expect(getTabVisibility({})).toMatchObject({ grants: false });
     expect(getTabVisibility({ structure: {} })).toMatchObject({
-      grants: false
+      grants: false,
     });
     expect(getTabVisibility({ structure: { grants: [] } })).toMatchObject({
-      grants: false
+      grants: false,
     });
     expect(getTabVisibility({ structure: { grants: [{}] } })).toMatchObject({
-      grants: true
+      grants: true,
     });
   });
 });

package/src/selectors/getGrantAvailableFilters.js

@@ -0,0 +1,17 @@
+import _ from "lodash/fp";
+import { createSelector } from "reselect";
+import { getGrantSelectedFilters } from "./getGrantSelectedFilters";
+
+const getGrantFilters = _.propOr({}, "grantFilters");
+
+export const getGrantAvailableFilters = createSelector(
+  getGrantFilters,
+  getGrantSelectedFilters,
+  (grantFilters, grantSelectedFilters) => {
+    return _.flow(
+      _.omitBy((values) => _.size(values) < 2),
+      _.keys,
+      _.without(grantSelectedFilters)
+    )(grantFilters);
+  }
+);

package/src/selectors/getGrantSelectedFilterActiveValues.js

@@ -0,0 +1,8 @@
+import _ from "lodash/fp";
+import { createSelector } from "reselect";
+
+export const getGrantSelectedFilterActiveValues = createSelector(
+  [_.prop("grantSelectedFilter"), _.prop("grantActiveFilters")],
+  (grantSelectedFilter, grantActiveFilters) =>
+    _.propOr([], grantSelectedFilter)(grantActiveFilters)
+);