@truedat/dd 4.28.1 → 4.28.5

package/src/components/index.js

@@ -1,5 +1,8 @@
 import DictionaryRoutes from "./DictionaryRoutes";
 import FilteredNav from "./FilteredNav";
+import GrantSelectedFilters from "./GrantSelectedFilters";
+import GrantsRoutes from "./GrantsRoutes";
+import GrantsTable from "./GrantsTable";
 import LineageDefs from "./LineageDefs";
 import LineageDownloadButton from "./LineageDownloadButton";
 import LineageGroup from "./LineageGroup";
@@ -54,6 +57,9 @@ import ValueConditionStructure from "./ValueConditionStructure";
 export {
   DictionaryRoutes,
   FilteredNav,
+  GrantsRoutes,
+  GrantSelectedFilters,
+  GrantsTable,
   LineageDefs,
   LineageDownloadButton,
   LineageGroup,

package/src/messages/en.js

@@ -13,6 +13,7 @@ export default {
   "execution.props.status": "Status",
   "filters.class.raw": "Class",
   "filters.confidential.raw": "Confidential",
+  "filters.data_structure_version.name.raw": "Structure",
   "filters.domain.name.raw": "Domain",
   "filters.field_type.raw": "Field Type",
   "filters.group.raw": "Group",
@@ -23,6 +24,7 @@ export default {
   "filters.system.name.raw": "System",
   "filters.tags.raw": "Tags",
   "filters.type.raw": "Type",
+  "filters.user_name": "User",
   "filters.with_content.raw": "Extra Info",
   "filters.with_content.raw.false": "Without extra info",
   "filters.with_profiling.raw": "Profile",
@@ -35,6 +37,12 @@ export default {
   "grant.header.data_structure": "Structure",
   "grant.header.end_date": "Expires",
   "grant.header.start_date": "Access granted",
+  "grant.updated_at": "Last changed",
+  "grants.header": "Grants",
+  "grants.retrieved.results": "{count} grants found",
+  "grants.search.placeholder": "Enter a search...",
+  "grants.search.results.empty": "No grants found",
+  "grants.subheader": "Grants",
   "filters.with_content.raw.true": "Extra Info",
   "graph.actions.download.popup": "Select a graph",
   "graph.actions.download.tooltip": "Download to csv",
@@ -375,5 +383,5 @@ export default {
   "updateSystem.error.df_content.invalid content": "Invalid template content",
   "structure.grant.has_grant": "You have granted access on this structure",
   "visualization.title.impact": "Impact Analysis",
-  "visualization.title.lineage": "Lineage Analysis"
+  "visualization.title.lineage": "Lineage Analysis",
 };

package/src/messages/es.js

@@ -14,6 +14,7 @@ export default {
   "execution.props.status": "Estado",
   "filters.class.raw": "Clase",
   "filters.confidential.raw": "Confidencial",
+  "filters.data_structure_version.name.raw": "Estructura",
   "filters.domain.name.raw": "Dominio",
   "filters.field_type.raw": "Tipo de Campo",
   "filters.group.raw": "Grupo",
@@ -24,6 +25,7 @@ export default {
   "filters.system.name.raw": "Sistema",
   "filters.tags.raw": "Etiquetas",
   "filters.type.raw": "Tipo",
+  "filters.user_name": "Usuario",
   "filters.with_content.raw": "Extra Info",
   "filters.with_content.raw.false": "Sin información extra",
   "filters.with_profiling.raw": "Perfilado",
@@ -36,6 +38,12 @@ export default {
   "grant.header.end_date": "Expira",
   "grant.header.start_date": "Acceso desde",
   "grant.header.user": "Cuenta",
+  "grant.updated_at": "Actualizada",
+  "grants.header": "Grants",
+  "grants.retrieved.results": "{count} grants encontrados",
+  "grants.search.placeholder": "Introduce una busqueda...",
+  "grants.search.results.empty": "Ningún grant encontrado",
+  "grants.subheader": "Grants",
   "filters.with_content.raw.true": "Contiene información extra",
   "graph.actions.download.popup": "Seleccione un grafo",
   "graph.actions.download.tooltip": "Descargar en csv",
@@ -382,5 +390,5 @@ export default {
     "Contenido de plantilla inválido",
   "structure.grant.has_grant": "Tienes acceso a la estructura",
   "visualization.title.impact": "Análisis de Impacto",
-  "visualization.title.lineage": "Análisis de Linaje"
+  "visualization.title.lineage": "Análisis de Linaje",
 };

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

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

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

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

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

@@ -0,0 +1,113 @@
+import {
+  clearGrantFilters,
+  removeGrantFilter,
+  searchGrants,
+  selectGrantPage,
+  sortGrants,
+  toggleGrantFilterValue,
+  clearGrantsSort,
+} from "../../routines";
+import { initialState } from "../grantQuery";
+import { grantQuery } from "..";
+
+const fooState = { foo: "bar" };
+
+describe("reducers: grantQuery", () => {
+  it("should provide the initial state", () => {
+    expect(grantQuery(undefined, {})).toEqual(initialState);
+  });
+
+  it("should handle the selectGrantPage.TRIGGER action", () => {
+    const activePage = 123;
+    const payload = { activePage };
+    expect(
+      grantQuery(fooState, { type: selectGrantPage.TRIGGER, payload })
+    ).toEqual({ ...fooState, page: activePage });
+  });
+
+  it("should handle the clearGrantFilters.TRIGGER action", () => {
+    expect(grantQuery(fooState, { type: clearGrantFilters.TRIGGER })).toEqual({
+      ...fooState,
+      page: 1,
+      query: "",
+    });
+  });
+
+  it("should handle the clearGrantsSort.TRIGGER action", () => {
+    expect(grantQuery(fooState, { type: clearGrantsSort.TRIGGER })).toEqual({
+      ...fooState,
+      sort: [{ "data_structure_version.name.raw": "asc" }],
+    });
+  });
+
+  it("should return default page when filter is removed", () => {
+    expect(grantQuery(fooState, { type: removeGrantFilter.TRIGGER })).toEqual({
+      ...fooState,
+      page: 1,
+    });
+  });
+
+  // // it("should return default page when user filter is applied", () => {
+  // //   expect(
+  // //     grantQuery(fooState, { type: applyStructureUserFilter.TRIGGER })
+  // //   ).toEqual({
+  // //     ...fooState,
+  // //     page: 1
+  // //   });
+  // // });
+
+  it("should return default page when filter is toggled", () => {
+    expect(
+      grantQuery(fooState, { type: toggleGrantFilterValue.TRIGGER })
+    ).toEqual({
+      ...fooState,
+      page: 1,
+    });
+  });
+
+  describe("action: sortGrants.TRIGGER", () => {
+    it("should set sort from payload and set page to 1", () => {
+      const payload = [{ name2: "asc" }];
+      expect(
+        grantQuery(fooState, { type: sortGrants.TRIGGER, payload })
+      ).toMatchObject({ sort: [{ name2: "asc" }] });
+    });
+  });
+
+  describe("action: searchGrants.TRIGGER", () => {
+    const query = "some query";
+    it("should set the query from the payload", () => {
+      const payload = { query };
+      expect(
+        grantQuery(fooState, { type: searchGrants.TRIGGER, payload })
+      ).toMatchObject({ query });
+    });
+
+    it("when query is not empty it should order by relevance and name", () => {
+      const payload = { query };
+      expect(
+        grantQuery(fooState, { type: searchGrants.TRIGGER, payload })
+      ).toMatchObject({
+        query,
+        sort: [
+          { _score: "desc" },
+          { "data_structure_version.name.raw": "asc" },
+        ],
+      });
+    });
+
+    it("when query is empty it should order by name", () => {
+      const payload = { query: "" };
+      expect(
+        grantQuery(fooState, { type: searchGrants.TRIGGER, payload })
+      ).toMatchObject({
+        query: "",
+        sort: [{ "data_structure_version.name.raw": "asc" }],
+      });
+    });
+  });
+
+  it("should ignore unknown actions", () => {
+    expect(grantQuery(fooState, { type: "FOO" })).toBe(fooState);
+  });
+});

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

@@ -0,0 +1,102 @@
+import { clearGrants, fetchGrants, updateGrant } from "../../routines";
+import { grants, initialState } from "../grants";
+
+const fooState = { foo: "bar" };
+const someGrants = [
+  {
+    data_structure_version: {
+      data_structure_id: 22075,
+      description: "DEscripción",
+      domain: {
+        external_id: "Demo Truedat",
+        id: 3,
+        name: "Demo Truedat",
+        parent_ids: [],
+        updated_at: "2020-07-21 07:45:41.068703Z",
+      },
+      external_id: "sap:Clientes:KNA1",
+      metadata: {},
+      mutable_metadata: null,
+      name: "KNA1",
+    },
+    detail: {},
+    end_date: "2023-05-16",
+    id: 6,
+    start_date: "2020-05-17",
+    user: {
+      email: "user1@example.com",
+      full_name: "user_full_name_1",
+      user_name: "user1",
+    },
+    user_id: 23,
+  },
+  {
+    data_structure_version: {
+      data_structure_id: 4570466,
+      description: null,
+      domain: {
+        external_id: "Truedat",
+        id: 2,
+        name: "Truedat",
+        parent_ids: [],
+        updated_at: "2020-07-28 13:21:21.938189Z",
+      },
+      external_id: "postgres://postgres/td_metrics/public/concepts",
+      metadata: {
+        alias: "Truedat-PostgreSQL",
+        database: "td_metrics",
+        host: "postgres",
+        schema: "public",
+        type: "BASE TABLE",
+      },
+      mutable_metadata: null,
+      name: "concepts",
+    },
+    detail: {
+      access_type: "admin",
+    },
+    end_date: "2023-05-18",
+    id: 8,
+    start_date: "2011-05-17",
+    user: {
+      email: "user2@example.com",
+      full_name: "user_full_name_2",
+      user_name: "user2",
+    },
+    user_id: 171,
+  },
+];
+
+describe("reducers: grants", () => {
+  it("should provide the initial state", () => {
+    expect(grants(undefined, {})).toBe(initialState);
+  });
+
+  it("should handle the clearGrants.SUCCESS action", () => {
+    expect(grants(fooState, { type: clearGrants.TRIGGER })).toBe(initialState);
+  });
+
+  it("should handle the fetchGrants.SUCCESS action", () => {
+    const data = { data: someGrants };
+
+    expect(
+      grants(fooState, {
+        type: fetchGrants.SUCCESS,
+        payload: { data },
+      })
+    ).toMatchObject(someGrants);
+  });
+
+  it("should handle the updateGrant.SUCCESS action", () => {
+    const state = [{ id: 1 }, { id: 2 }];
+    const data = { id: 1, user_id: "123" };
+    const expected = [data, { id: 2 }];
+    expect(
+      grants(state, { type: updateGrant.SUCCESS, payload: { data } })
+    ).toMatchObject(expected);
+  });
+
+  it("should ignore unknown actions", () => {
+    expect(grants(fooState, { type: "FOO" })).toBe(fooState);
+  });
+});

package/src/reducers/grantActiveFilters.js

@@ -0,0 +1,46 @@
+import _ from "lodash/fp";
+import {
+  addGrantFilter,
+  closeGrantFilter,
+  removeGrantFilter,
+  resetGrantFilters,
+  toggleGrantFilterValue,
+} from "../routines";
+
+export const initialState = {};
+
+export const grantActiveFilters = (state = initialState, { type, payload }) => {
+  switch (type) {
+    case addGrantFilter.TRIGGER: {
+      const { filter } = payload;
+      return { ...state, [filter]: [] };
+    }
+    case closeGrantFilter.TRIGGER: {
+      const { filter } = payload;
+      const values = _.propOr([], filter)(state);
+      return _.isEmpty(values)
+        ? _.omit(filter)(state)
+        : { ...state, [filter]: values };
+    }
+    case removeGrantFilter.TRIGGER: {
+      const { filter } = payload;
+      return _.omit(filter)(state);
+    }
+    case resetGrantFilters.TRIGGER: {
+      return initialState;
+    }
+    case toggleGrantFilterValue.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;
+  }
+};