@truedat/dd 6.6.0 → 6.6.2

package/src/components/StructureFilters.js

@@ -1,19 +0,0 @@
-import { bindActionCreators } from "redux";
-import { connect } from "react-redux";
-import { AvailableFilters } from "@truedat/core/components";
-import { addStructureFilter, resetStructureFilters } from "../routines";
-import { getStructureAvailableFilters } from "../selectors";
-
-const mapStateToProps = (state) => ({
-  filters: getStructureAvailableFilters(state),
-  disabled: state.structureFiltersLoading,
-  loading: state.structureFiltersLoading,
-});
-
-const mapDispatchToProps = (dispatch) =>
-  bindActionCreators(
-    { addFilter: addStructureFilter, resetFilters: resetStructureFilters },
-    dispatch
-  );
-
-export default connect(mapStateToProps, mapDispatchToProps)(AvailableFilters);

package/src/components/StructureFiltersLoader.js

@@ -1,32 +0,0 @@
-import { connect } from "react-redux";
-import { bindActionCreators } from "redux";
-import { FiltersLoader } from "@truedat/core/components";
-import { makeActiveFiltersSelector } from "@truedat/core/selectors";
-import {
-  clearStructureFilters,
-  fetchStructureFilters,
-  clearStructuresSort,
-} from "../routines";
-
-const mapDispatchToProps = (dispatch) =>
-  bindActionCreators(
-    {
-      clearFilters: clearStructureFilters,
-      fetchFilters: fetchStructureFilters,
-      clearSort: clearStructuresSort,
-    },
-    dispatch
-  );
-
-const makeMapStateToProps = () => {
-  const activeFiltersSelector = makeActiveFiltersSelector(
-    "structureActiveFilters"
-  );
-  const mapStateToProps = (state, props) => ({
-    selectedFilter: state.structureSelectedFilter,
-    filters: activeFiltersSelector(state, props),
-  });
-  return mapStateToProps;
-};
-
-export default connect(makeMapStateToProps, mapDispatchToProps)(FiltersLoader);

package/src/components/StructureSelectedFilters.js

@@ -1,94 +0,0 @@
-import _ from "lodash/fp";
-import { bindActionCreators, compose } from "redux";
-import { connect } from "react-redux";
-import { injectIntl } from "react-intl";
-import { SelectedFilters } from "@truedat/core/components";
-import { makeOption } from "@truedat/core/services/i18n";
-import {
-  applyUserSearchFilter,
-  closeStructureFilter,
-  deleteUserSearchFilter,
-  openStructureFilter,
-  removeStructureFilter,
-  resetStructureFilters,
-  saveUserSearchFilters,
-  toggleStructureFilterValue,
-} from "../routines";
-import {
-  getStructureSelectedFilterActiveValues,
-  getStructureSelectedFilters,
-  getStructureSelectedFilterValues,
-  getStructureFilterTypes,
-} from "../selectors";
-
-const translations = (formatMessage, structureTypes) => ({
-  "type.raw": (v) =>
-    formatMessage({
-      id: `structure.type.${v}.text`,
-      defaultMessage:
-        _.prop("translation")(_.find(_.propEq("name", v))(structureTypes)) || v,
-    }),
-  "with_content.raw": (v) =>
-    formatMessage({
-      id: `filters.with_content.raw.${v}`,
-      defaultMessage: v,
-    }),
-  "with_profiling.raw": (v) =>
-    formatMessage({
-      id: `filters.with_profiling.raw.${v}`,
-      defaultMessage: v,
-    }),
-  linked_concepts: (v) =>
-    formatMessage({ id: `filters.linked_concepts.${v}`, defaultMessage: v }),
-});
-
-export const mapStateToProps = (state, ownProps) => {
-  const formatMessage = _.pathOr(_.prop("id"), "intl.formatMessage")(ownProps);
-  const {
-    selectedUserSearchFilter: selectedUserFilter,
-    structureActiveFilters: activeFilters,
-    structureFiltersLoading: loading,
-    structureSelectedFilter: selectedFilter,
-    structureTypes,
-    userSearchFilters: userFilters,
-  } = state;
-  const selectedFilterValues = getStructureSelectedFilterValues(state);
-  const selectedFilterActiveValues =
-    getStructureSelectedFilterActiveValues(state);
-  const selectedFilters = getStructureSelectedFilters(state);
-
-  return {
-    loading,
-    filterTypes: getStructureFilterTypes(state),
-    selectedFilter,
-    selectedFilters,
-    selectedFilterActiveValues,
-    selectedFilterValues: _.map(
-      makeOption(translations(formatMessage, structureTypes), selectedFilter)
-    )(selectedFilterValues),
-    selectedUserFilter,
-    activeFilters,
-    userFilters,
-    userFilterScope: "data_structure",
-  };
-};
-
-const mapDispatchToProps = (dispatch) =>
-  bindActionCreators(
-    {
-      applyUserFilter: applyUserSearchFilter,
-      closeFilter: closeStructureFilter,
-      deleteUserFilter: deleteUserSearchFilter,
-      openFilter: openStructureFilter,
-      removeFilter: removeStructureFilter,
-      resetFilters: resetStructureFilters,
-      saveFilters: saveUserSearchFilters,
-      toggleFilterValue: toggleStructureFilterValue,
-    },
-    dispatch
-  );
-
-export default compose(
-  injectIntl,
-  connect(mapStateToProps, mapDispatchToProps)
-)(SelectedFilters);

package/src/components/__tests__/StructureDateFilter.spec.js

@@ -1,11 +0,0 @@
-import React from "react";
-import { shallow } from "enzyme";
-import { StructureDateFilter } from "../StructureDateFilter";
-
-describe("<StructureDateFilter/>", () => {
-  it("matches the latest snapshot", () => {
-    const props = { active: true };
-    const wrapper = shallow(<StructureDateFilter {...props} />);
-    expect(wrapper).toMatchSnapshot();
-  });
-});

package/src/components/__tests__/__snapshots__/StructureDateFilter.spec.js.snap

@@ -1,13 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`<StructureDateFilter/> matches the latest snapshot 1`] = `
-<DateFilter
-  defaultValues={{}}
-  label={
-    <Memo(MemoizedFormattedMessage)
-      id="structure.updated_at"
-    />
-  }
-  name="updated_at"
-/>
-`;

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

@@ -1,100 +0,0 @@
-import { initialState } from "../structureActiveFilters";
-import {
-  addStructureFilter,
-  applyUserSearchFilter,
-  clearStructureFilters,
-  closeStructureFilter,
-  removeStructureFilter,
-  resetStructureFilters,
-  toggleStructureFilterValue,
-} from "../../routines";
-import { structureActiveFilters } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: structureActiveFilters", () => {
-  it("should provide the initial state", () => {
-    expect(structureActiveFilters(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the clearStructureFilters.TRIGGER action", () => {
-    expect(
-      structureActiveFilters(fooState, {
-        type: clearStructureFilters.TRIGGER,
-      })
-    ).toEqual(initialState);
-  });
-
-  it("should handle the addStructureFilter.TRIGGER action", () => {
-    const filter = "baz";
-    const payload = { filter };
-    expect(
-      structureActiveFilters(fooState, {
-        type: addStructureFilter.TRIGGER,
-        payload,
-      })
-    ).toEqual({ ...fooState, baz: [] });
-  });
-
-  it("should handle the applyUserSearchFilter.TRIGGER action", () => {
-    const filters = { country: ["Sp"] };
-    const payload = { userFilter: { filters }, scope: "data_structure" };
-    expect(
-      structureActiveFilters(fooState, {
-        type: applyUserSearchFilter.TRIGGER,
-        payload,
-      })
-    ).toEqual({ ...filters });
-  });
-
-  it("should handle the closeStructureFilter.TRIGGER action", () => {
-    const foo = ["foo1"];
-    const bar = [];
-    const state = { foo, bar };
-    const payload = { filter: "bar" };
-    expect(
-      structureActiveFilters(state, {
-        type: closeStructureFilter.TRIGGER,
-        payload,
-      })
-    ).toEqual({ foo });
-  });
-
-  it("should handle the removeStructureFilter.TRIGGER action", () => {
-    const foo = ["foo1"];
-    const bar = [];
-    const state = { foo, bar };
-    const payload = { filter: "foo" };
-    expect(
-      structureActiveFilters(state, {
-        type: removeStructureFilter.TRIGGER,
-        payload,
-      })
-    ).toEqual({ bar });
-  });
-
-  it("should handle the resetStructureFilters.TRIGGER action", () => {
-    expect(
-      structureActiveFilters(fooState, {
-        type: resetStructureFilters.TRIGGER,
-      })
-    ).toEqual(initialState);
-  });
-
-  it("should handle the toggleStructureFilterValue.TRIGGER action", () => {
-    const foo = ["foo1", "foo2", "foo3"];
-    const bar = [];
-    const state = { foo, bar };
-    const payload = { filter: "foo", value: "foo2" };
-    expect(
-      structureActiveFilters(state, {
-        type: toggleStructureFilterValue.TRIGGER,
-        payload,
-      })
-    ).toEqual({ foo: ["foo1", "foo3"], bar });
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(structureActiveFilters(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

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

@@ -1,57 +0,0 @@
-import {
-  applyStructureDateFilter,
-  clearStructureFilters,
-  toggleStructureDateFilter
-} from "../../routines";
-import { initialState, structureDateFilter } from "../structureDateFilter";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: structureDateFilter", () => {
-  it("should provide the initial state", () => {
-    expect(structureDateFilter(undefined, {})).toBe(initialState);
-  });
-
-  it("should handle the clearStructureFilters.TRIGGER action", () => {
-    expect(
-      structureDateFilter(fooState, { type: clearStructureFilters.TRIGGER })
-    ).toBe(initialState);
-  });
-
-  it("should handle the toggleStructureDateFilter.TRIGGER action", () => {
-    expect(
-      structureDateFilter(
-        { active: false },
-        { type: toggleStructureDateFilter.TRIGGER }
-      )
-    ).toEqual({ active: true });
-
-    expect(
-      structureDateFilter(
-        { active: true },
-        { type: toggleStructureDateFilter.TRIGGER }
-      )
-    ).toEqual({ active: false });
-  });
-
-  it("should handle the applyStructureDateFilter.TRIGGER action", () => {
-    const payload = {
-      name: "some_date",
-      type: "range",
-      value: "2020-01-01 - 2020-02-02"
-    };
-    expect(
-      structureDateFilter(
-        { active: true },
-        {
-          type: applyStructureDateFilter.TRIGGER,
-          payload
-        }
-      )
-    ).toEqual({ ...payload, active: true });
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(structureDateFilter(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

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

@@ -1,37 +0,0 @@
-import { clearStructureFilters, fetchStructureFilters } from "../../routines";
-import { structureFilters } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: structureFilters", () => {
-  const initialState = {};
-
-  it("should provide the initial state", () => {
-    expect(structureFilters(undefined, {})).toEqual(initialState);
-  });
-
-  it("should handle the clearStructureFilters.TRIGGER action", () => {
-    expect(
-      structureFilters(fooState, { type: clearStructureFilters.TRIGGER })
-    ).toEqual(initialState);
-  });
-
-  it("should handle the fetchStructureFilters.SUCCESS action", () => {
-    const filter1 = { values: ["value1", "value2"] };
-    const filter2 = { values: ["value1", "value2"] };
-    const data = { filter1, filter2: { values: ["value1"] } };
-    const payload = { data: { data } };
-    const state = { filter2 };
-
-    expect(
-      structureFilters(state, {
-        type: fetchStructureFilters.SUCCESS,
-        payload,
-      })
-    ).toEqual(data);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(structureFilters(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

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

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

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

@@ -1,38 +0,0 @@
-import { clearStructures, fetchStructures } from "../../routines";
-import { structuresActions, initialState } from "../structuresActions";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: structuresActions", () => {
-  it("should provide the initial state", () => {
-    expect(structuresActions(undefined, {})).toBe(initialState);
-  });
-
-  it("should handle the clearStructures.TRIGGER action", () => {
-    expect(structuresActions(fooState, { type: clearStructures.TRIGGER })).toBe(
-      initialState
-    );
-  });
-
-  it("should handle the fetchStructures.TRIGGER action", () => {
-    expect(structuresActions(fooState, { type: fetchStructures.TRIGGER })).toBe(
-      initialState
-    );
-  });
-
-  it("should handle the fetchStructures.SUCCESS action", () => {
-    const _actions = { bulkUpdate: {} };
-    const data = { _actions };
-
-    expect(
-      structuresActions(fooState, {
-        type: fetchStructures.SUCCESS,
-        payload: { data },
-      })
-    ).toMatchObject(_actions);
-  });
-
-  it("should ignore unknown actions", () => {
-    expect(structuresActions(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

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

@@ -1,26 +0,0 @@
-import { fetchStructures } from "../../routines";
-import { structuresLoading } from "..";
-
-const fooState = { foo: "bar" };
-
-describe("reducers: structuresLoading", () => {
-  it("should provide the initial state", () => {
-    expect(structuresLoading(undefined, {})).toBe(false);
-  });
-
-  it("should be true after receiving the fetchStructures.TRIGGER action", () => {
-    expect(structuresLoading(false, { type: fetchStructures.TRIGGER })).toBe(
-      true
-    );
-  });
-
-  it("should be false after receiving the fetchStructures.FULFILL action", () => {
-    expect(structuresLoading(true, { type: fetchStructures.FULFILL })).toBe(
-      false
-    );
-  });
-
-  it("should ignore unhandled actions", () => {
-    expect(structuresLoading(fooState, { type: "FOO" })).toBe(fooState);
-  });
-});

package/src/reducers/structureActiveFilters.js

@@ -1,58 +0,0 @@
-import _ from "lodash/fp";
-import { isEmpty, omit, prop, propOr } from "lodash/fp";
-import {
-  addStructureFilter,
-  applyUserSearchFilter,
-  clearStructureFilters,
-  closeStructureFilter,
-  removeStructureFilter,
-  resetStructureFilters,
-  toggleStructureFilterValue,
-} from "../routines";
-
-export const initialState = {};
-
-export const structureActiveFilters = (
-  state = initialState,
-  { type, payload }
-) => {
-  switch (type) {
-    case clearStructureFilters.TRIGGER:
-      return initialState;
-    case addStructureFilter.TRIGGER: {
-      const { filter } = payload;
-      return { ...state, [filter]: [] };
-    }
-    case applyUserSearchFilter.TRIGGER: {
-      const { userFilter, scope } = payload;
-      return scope === "data_structure" ? prop("filters")(userFilter) : state;
-    }
-    case closeStructureFilter.TRIGGER: {
-      const { filter } = payload;
-      const values = propOr([], filter)(state);
-      return isEmpty(values)
-        ? omit(filter)(state)
-        : { ...state, [filter]: values };
-    }
-    case removeStructureFilter.TRIGGER: {
-      const { filter } = payload;
-      return omit(filter)(state);
-    }
-    case resetStructureFilters.TRIGGER: {
-      return initialState;
-    }
-    case toggleStructureFilterValue.TRIGGER: {
-      const { filter, value } = payload;
-      if (_.isArray(value)) {
-        return { ...state, [filter]: value };
-      }
-      const values = _.propOr([], filter)(state);
-      const nextValues = _.includes(value)(values)
-        ? _.without([value])(values)
-        : _.union([value])(values);
-      return { ...state, [filter]: nextValues };
-    }
-    default:
-      return state;
-  }
-};

package/src/reducers/structureCount.js

@@ -1,20 +0,0 @@
-import _ from "lodash/fp";
-import { fetchStructures, clearStructures } from "../routines";
-
-const initialState = 0;
-
-const structureCount = (state = initialState, { type, payload }) => {
-  switch (type) {
-    case clearStructures.TRIGGER:
-      return initialState;
-    case fetchStructures.SUCCESS: {
-      const headers = _.propOr({}, "headers")(payload);
-      const count = _.propOr("0", "x-total-count")(headers);
-      return parseInt(count);
-    }
-    default:
-      return state;
-  }
-};
-
-export { structureCount };

package/src/reducers/structureDateFilter.js

@@ -1,33 +0,0 @@
-import {
-  applyStructureDateFilter,
-  clearStructureFilters,
-  toggleStructureDateFilter,
-} from "../routines";
-
-export const initialState = {
-  active: false,
-  name: "updated_at",
-  type: "since",
-  unit: "d",
-  value: "1",
-};
-
-export const structureDateFilter = (
-  state = initialState,
-  { type, payload }
-) => {
-  switch (type) {
-    case clearStructureFilters.TRIGGER:
-      return initialState;
-    case toggleStructureDateFilter.TRIGGER: {
-      const { active } = state;
-      return { ...state, active: !active };
-    }
-    case applyStructureDateFilter.TRIGGER: {
-      const { active } = state;
-      return { ...payload, active };
-    }
-    default:
-      return state;
-  }
-};

package/src/reducers/structureFilters.js

@@ -1,21 +0,0 @@
-import _ from "lodash/fp";
-import { clearStructureFilters, fetchStructureFilters } from "../routines";
-
-const initialState = {};
-
-const structureFilters = (state = initialState, { type, payload }) => {
-  switch (type) {
-    case clearStructureFilters.TRIGGER:
-    case fetchStructureFilters.TRIGGER:
-      return initialState;
-    case fetchStructureFilters.SUCCESS:
-      return _.flow(
-        _.propOr({}, "data.data"),
-        _.omitBy(_.flow(_.getOr([], "values"), _.isEmpty))
-      )(payload);
-    default:
-      return state;
-  }
-};
-
-export { structureFilters };

package/src/reducers/structureFiltersLoading.js

@@ -1,14 +0,0 @@
-import { fetchStructureFilters } from "../routines";
-
-const structureFiltersLoading = (state = false, { type }) => {
-  switch (type) {
-    case fetchStructureFilters.REQUEST:
-      return true;
-    case fetchStructureFilters.FULFILL:
-      return false;
-    default:
-      return state;
-  }
-};
-
-export { structureFiltersLoading };