@reltio/dashboard 1.4.1584 → 1.4.1586-mui5

package/src/hooks/__tests__/useWorkflowTasksRequest.specs.tsx

@@ -0,0 +1,388 @@
+import React from 'react';
+import {act} from 'react-dom/test-utils';
+import {mount} from 'enzyme';
+import * as mdmSdkModule from '@reltio/mdm-sdk';
+import {useWorkflowTasksRequest} from '../useWorkflowTasksRequest';
+import {WorkflowTasksCategories} from '../../types/WorkflowTasks';
+import {createStore} from 'redux';
+import {Provider} from 'react-redux';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    getTasksForTenant: jest.fn(),
+    getGroupTasksForTenant: jest.fn(),
+    getDataChangeRequest: jest.fn(),
+    getEntitiesByUris: jest.fn()
+}));
+
+type Props = {
+    options: {
+        max?: number;
+        offset?: number;
+        tasksCategory: WorkflowTasksCategories;
+    };
+};
+
+describe('useWorkflowTasksRequest behavior', () => {
+    const TestComponent = ({options}: Props) => {
+        const {state, data, reload} = useWorkflowTasksRequest(options);
+        return state ? <div data-test={{state, data, reload}} /> : null;
+    };
+    const getHooksValues = (component) => component.find('TestComponent').childAt(0).prop('data-test');
+
+    let initialStore;
+
+    const createTestStore = () => {
+        const reducer = (state = initialStore) => {
+            return state;
+        };
+        return createStore(reducer);
+    };
+
+    beforeEach(() => {
+        initialStore = {
+            ui: {
+                paths: {
+                    workflowPath: 'workflowPath',
+                    workflowEnvironmentURL: 'workflowEnvironmentURL'
+                }
+            },
+            tenant: {
+                id: 'tenant'
+            },
+            user: {
+                username: 'polina.arsenteva'
+            }
+        };
+    });
+
+    let resolveTasks;
+
+    const getTasksForTenantSpy = jest.spyOn(mdmSdkModule, 'getTasksForTenant');
+    const getEntitiesByUrisSpy = jest.spyOn(mdmSdkModule, 'getEntitiesByUris');
+    const getGroupTasksForTenantSpy = jest.spyOn(mdmSdkModule, 'getGroupTasksForTenant');
+    const getDataChangeRequestSpy = jest.spyOn(mdmSdkModule, 'getDataChangeRequest');
+
+    beforeAll(() => {
+        getTasksForTenantSpy.mockImplementation(() => {
+            return new Promise((_resolve) => {
+                resolveTasks = () =>
+                    _resolve({
+                        status: 'ok',
+                        data: [
+                            {
+                                assignee: 'polina.arsenteva',
+                                objectURIs: ['entities/1fIVXrYH'],
+                                taskType: 'review',
+                                taskId: '123',
+                                createdBy: 'sairam.singireesu@reltio.com',
+                                priorityClass: 'Medium',
+                                createTime: 1621534310502,
+                                dueDate: 1621707110507,
+                                displayName: 'Delete Review',
+                                processDefinitionDisplayName: 'Recommend for Delete'
+                            }
+                        ],
+                        total: 1
+                    });
+            });
+        });
+        getEntitiesByUrisSpy.mockResolvedValue([
+            {
+                uri: 'entities/1fIVXrYH',
+                type: 'configuration/entityTypes/HCO',
+                label: 'Belize',
+                secondaryLabel: ''
+            }
+        ]);
+        getGroupTasksForTenantSpy.mockImplementation(() => {
+            return new Promise((_resolve) => {
+                resolveTasks = () =>
+                    _resolve({
+                        status: 'ok',
+                        data: [
+                            {
+                                assignee: 'johnconnor1131',
+                                taskType: 'review',
+                                taskId: '123',
+                                objectURIs: ['changeRequests/7ZotlRoP', 'entities/1aAyKH7k'],
+                                createdBy: 'sairam.singireesu@reltio.com',
+                                priorityClass: 'Medium',
+                                createTime: 1620897479535,
+                                dueDate: 1621070279536,
+                                displayName: 'DCR Review',
+                                processDefinitionDisplayName: 'Data Change Request Review'
+                            },
+                            {
+                                assignee: 'marat.ahmetzyanov',
+                                objectURIs: ['changeRequests/3BlTJj8z', 'entities/1RVnhXSL'],
+                                createdBy: 'marat.ahmetzyanov',
+                                priorityClass: 'Medium',
+                                taskType: 'dcrReview',
+                                createTime: 1644499067234,
+                                dueDate: 1644671867234,
+                                taskId: '30746510',
+                                displayName: 'DCR Review',
+                                processDefinitionDisplayName: 'Data Change Request Review'
+                            }
+                        ],
+                        total: 2
+                    });
+            });
+        });
+        getDataChangeRequestSpy
+            .mockResolvedValueOnce({
+                uri: 'changeRequests/7ZotlRoP',
+                createdBy: 'sairam.singireesu@reltio.com',
+                createdTime: 1620897478450,
+                updatedBy: 'sairam.singireesu@reltio.com',
+                updatedTime: 1620897478450,
+                changes: {
+                    'entities/1aAyKH7k': [
+                        {
+                            id: '7ZotlNY9',
+                            type: 'UPDATE_TAGS',
+                            createdTime: 1620897478450,
+                            createdBy: 'sairam.singireesu@reltio.com',
+                            newValue: ['lkl']
+                        }
+                    ]
+                },
+                objectsInfo: {
+                    'entities/1aAyKH7k': {
+                        type: 'configuration/entityTypes/HCO',
+                        label: 'Bahrain',
+                        secondaryLabel: '',
+                        isExist: true
+                    }
+                },
+                type: 'configuration/changeRequestTypes/default',
+                state: 'AWAITING_REVIEW'
+            })
+            .mockResolvedValueOnce({
+                uri: 'changeRequests/3BlTJj8z',
+                createdBy: 'marat.ahmetzyanov',
+                createdTime: 1644499065831,
+                updatedBy: 'marat.ahmetzyanov',
+                updatedTime: 1644499065831,
+                changes: {
+                    'entities/1RVnhXSL': [
+                        {
+                            id: '3BlTJnPF',
+                            type: 'CREATE_ENTITY',
+                            createdTime: 1644499065831,
+                            createdBy: 'marat.ahmetzyanov',
+                            newValue: {
+                                uri: 'entities/1RVnhXSL',
+                                type: 'configuration/entityTypes/HCPLongName',
+                                attributes: {
+                                    CountryCode: [
+                                        {
+                                            value: 'Italy',
+                                            lookupCode: 'IT',
+                                            lookupRawValue: 'IT'
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    ]
+                },
+                objectsInfo: {
+                    'entities/1RVnhXSL': {
+                        type: 'configuration/entityTypes/HCPLongName',
+                        label: 'last name',
+                        secondaryLabel: '',
+                        isExist: false
+                    }
+                },
+                type: 'configuration/changeRequestTypes/default',
+                state: 'AWAITING_REVIEW'
+            });
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should send request for MY tasks and be in the loading state, and be in loaded state once data is loaded', async () => {
+        const store = createTestStore();
+        const options = {
+            tasksCategory: WorkflowTasksCategories.MY
+        };
+        const component = mount(
+            <Provider store={store}>
+                <TestComponent options={options} />
+            </Provider>
+        );
+        expect(getHooksValues(component).state).toBe('loading');
+        expect(getHooksValues(component).data).toEqual([]);
+
+        await act(async () => {
+            resolveTasks();
+        });
+
+        component.update();
+        expect(getHooksValues(component).state).toBe('loaded');
+        expect(getHooksValues(component).data).toEqual([
+            {
+                assignee: 'polina.arsenteva',
+                objectURIs: ['entities/1fIVXrYH'],
+                createdBy: 'sairam.singireesu@reltio.com',
+                priorityClass: 'Medium',
+                createTime: 1621534310502,
+                dueDate: 1621707110507,
+                displayName: 'Delete Review',
+                processDefinitionDisplayName: 'Recommend for Delete',
+                taskId: '123',
+                taskType: 'review',
+                objects: [
+                    {
+                        uri: 'entities/1fIVXrYH',
+                        type: 'configuration/entityTypes/HCO',
+                        label: 'Belize',
+                        secondaryLabel: ''
+                    }
+                ]
+            }
+        ]);
+
+        expect(getTasksForTenantSpy).toBeCalledWith({
+            workflowPath: 'workflowPath',
+            environment: 'workflowEnvironmentURL',
+            tenant: 'tenant',
+            assignee: 'polina.arsenteva'
+        });
+        expect(getEntitiesByUrisSpy).toBeCalledWith(['entities/1fIVXrYH']);
+    });
+
+    it('should send request for TEAM tasks and be in the loading state, and be in loaded state once data is loaded', async () => {
+        const store = createTestStore();
+        const options = {
+            tasksCategory: WorkflowTasksCategories.TEAM
+        };
+        const component = mount(
+            <Provider store={store}>
+                <TestComponent options={options} />
+            </Provider>
+        );
+        expect(getHooksValues(component).state).toBe('loading');
+        expect(getHooksValues(component).data).toEqual([]);
+
+        await act(async () => {
+            resolveTasks();
+        });
+
+        component.update();
+        expect(getHooksValues(component).state).toBe('loaded');
+        expect(getHooksValues(component).data).toEqual([
+            {
+                assignee: 'johnconnor1131',
+                objectURIs: ['changeRequests/7ZotlRoP', 'entities/1aAyKH7k'],
+                createdBy: 'sairam.singireesu@reltio.com',
+                priorityClass: 'Medium',
+                createTime: 1620897479535,
+                dueDate: 1621070279536,
+                displayName: 'DCR Review',
+                processDefinitionDisplayName: 'Data Change Request Review',
+                taskId: '123',
+                taskType: 'review',
+                objects: [
+                    {
+                        uri: 'entities/1aAyKH7k',
+                        type: 'configuration/entityTypes/HCO',
+                        label: 'Bahrain',
+                        secondaryLabel: '',
+                        isExist: true
+                    }
+                ]
+            },
+            {
+                assignee: 'marat.ahmetzyanov',
+                objectURIs: ['changeRequests/3BlTJj8z', 'entities/1RVnhXSL'],
+                createdBy: 'marat.ahmetzyanov',
+                priorityClass: 'Medium',
+                taskType: 'dcrReview',
+                createTime: 1644499067234,
+                dueDate: 1644671867234,
+                taskId: '30746510',
+                displayName: 'DCR Review',
+                processDefinitionDisplayName: 'Data Change Request Review',
+                objects: [
+                    {
+                        uri: 'changeRequests/3BlTJj8z/changes/entities/1RVnhXSL',
+                        type: 'configuration/entityTypes/HCPLongName',
+                        label: 'last name',
+                        secondaryLabel: '',
+                        isExist: false
+                    }
+                ]
+            }
+        ]);
+
+        expect(getGroupTasksForTenantSpy).toBeCalledWith({
+            workflowPath: 'workflowPath',
+            environment: 'workflowEnvironmentURL',
+            tenant: 'tenant'
+        });
+        expect(getDataChangeRequestSpy).toBeCalledWith('changeRequests/7ZotlRoP');
+        expect(getEntitiesByUrisSpy).not.toHaveBeenCalled();
+    });
+
+    it('should send request with max, offset params for TEAM tasks and be in the loading state, and be in loaded state once data is loaded', async () => {
+        const store = createTestStore();
+        const options = {
+            tasksCategory: WorkflowTasksCategories.TEAM,
+            max: 10,
+            offset: 10
+        };
+        const component = mount(
+            <Provider store={store}>
+                <TestComponent options={options} />
+            </Provider>
+        );
+        expect(getHooksValues(component).state).toBe('loading');
+        expect(getHooksValues(component).data).toEqual([]);
+
+        await act(async () => {
+            resolveTasks();
+        });
+
+        expect(getGroupTasksForTenantSpy).toBeCalledWith({
+            workflowPath: 'workflowPath',
+            environment: 'workflowEnvironmentURL',
+            tenant: 'tenant',
+            max: 10,
+            offset: 10
+        });
+    });
+
+    it('should send request with max, offset params for MY tasks and be in the loading state, and be in loaded state once data is loaded', async () => {
+        const store = createTestStore();
+        const options = {
+            tasksCategory: WorkflowTasksCategories.MY,
+            max: 10,
+            offset: 10
+        };
+        const component = mount(
+            <Provider store={store}>
+                <TestComponent options={options} />
+            </Provider>
+        );
+        expect(getHooksValues(component).state).toBe('loading');
+        expect(getHooksValues(component).data).toEqual([]);
+
+        await act(async () => {
+            resolveTasks();
+        });
+
+        expect(getTasksForTenantSpy).toBeCalledWith({
+            workflowPath: 'workflowPath',
+            environment: 'workflowEnvironmentURL',
+            tenant: 'tenant',
+            assignee: 'polina.arsenteva',
+            max: 10,
+            offset: 10
+        });
+    });
+});

package/src/hooks/useActivitiesRequest.ts

@@ -0,0 +1,50 @@
+import {useCallback, useEffect, useState} from 'react';
+import {andThen, otherwise, pipe} from 'ramda';
+import {ActivitiesFilter, ActivityData, useActivitiesLoader, useSafePromise, RequestStates} from '@reltio/components';
+
+type Props = {
+    filter: ActivitiesFilter;
+    max: number;
+    offset: number;
+};
+
+export const useActivitiesRequest = ({filter, max, offset}: Props) => {
+    const [data, setData] = useState<ActivityData[]>([]);
+    const [total, setTotal] = useState(0);
+    const [requestState, setRequestState] = useState<RequestStates>(RequestStates.INIT);
+    const safePromise = useSafePromise();
+
+    const onError = (error) => {
+        console.error(error); // eslint-disable-line
+        setRequestState(RequestStates.ERROR);
+        setData([]);
+        setTotal(0);
+    };
+    const getActivities = useActivitiesLoader({filter, max, offset});
+
+    const loadData = useCallback(() => {
+        setRequestState(RequestStates.LOADING);
+        const onRequestFinished = ({data, total}: {data: ActivityData[]; total: number}) => {
+            setData(data);
+            setTotal(total);
+            setRequestState(RequestStates.LOADED);
+        };
+
+        const getData = pipe(getActivities, safePromise, andThen(onRequestFinished), otherwise(onError));
+        getData();
+    }, [getActivities]); // eslint-disable-line
+
+    const refreshAction = () => {
+        try {
+            loadData();
+        } catch (e) {
+            onError(e);
+        }
+    };
+
+    useEffect(() => {
+        refreshAction();
+    }, [loadData]);
+
+    return {state: requestState, data, total, reload: refreshAction};
+};

package/src/hooks/useEntityByTypeRequest.ts

@@ -0,0 +1,67 @@
+import {useEffect, useState, useCallback} from 'react';
+import {useSelector} from 'react-redux';
+import mdmModule from '@reltio/mdm-module';
+import {pipe, andThen, otherwise, when, always, unless} from 'ramda';
+import {requestFacets, localizeFacetValues} from '../services/facets';
+import {ChartData, RequestStates} from '@reltio/components';
+import {GlobalSearchRequestOptions} from '../types/SearchOptions';
+import {addEmptyEntityTypesFacets, getParentEntityTypeFacets, resolveTypeFacetsLabels} from '../services/entityTypes';
+
+type Props = {
+    hideEmpty?: boolean;
+    orderType?: string;
+    inheritChildren?: boolean;
+};
+
+const filters = [];
+
+export const useEntityByTypeRequest = ({orderType, inheritChildren, hideEmpty}: Props) => {
+    const [data, setData] = useState<ChartData[]>([]);
+    const [requestState, setRequestState] = useState<RequestStates>(RequestStates.INIT);
+    const metadata: Record<string, any> = useSelector(mdmModule.selectors.getMetadata);
+    const pageSize = metadata.entityTypes.length;
+    const {globalFilter, activityFilter}: GlobalSearchRequestOptions = useSelector(
+        mdmModule.selectors.getGlobalSearchRequestOptions
+    );
+
+    const searchByOv: boolean = useSelector(mdmModule.selectors.getShowSearchByOv);
+    const onError = (error) => {
+        console.error(error); // eslint-disable-line
+        setRequestState(RequestStates.ERROR);
+        setData([]);
+    };
+
+    const loadData = useCallback(() => {
+        setRequestState(RequestStates.LOADING);
+        const onRequestFinished = (data: ChartData[]) => {
+            setRequestState(RequestStates.LOADED);
+            setData(data);
+        };
+
+        const getData = pipe(
+            requestFacets,
+            andThen(unless(always(hideEmpty), addEmptyEntityTypesFacets(metadata))),
+            andThen(when(always(inheritChildren), getParentEntityTypeFacets(metadata))),
+            andThen(resolveTypeFacetsLabels(metadata)),
+            andThen(localizeFacetValues),
+            andThen(onRequestFinished),
+            otherwise(onError)
+        );
+
+        getData({attribute: 'type', pageSize, filters, globalFilter, searchByOv, activityFilter, orderType});
+    }, [hideEmpty, metadata, inheritChildren, pageSize, globalFilter, searchByOv, activityFilter, orderType]);
+
+    const refreshAction = () => {
+        try {
+            loadData();
+        } catch (e) {
+            onError(e);
+        }
+    };
+
+    useEffect(() => {
+        refreshAction();
+    }, [loadData]);
+
+    return {state: requestState, data, reload: refreshAction};
+};

package/src/hooks/useFacetRequest.ts

@@ -0,0 +1,117 @@
+import {useCallback, useEffect, useState, useContext, useMemo} from 'react';
+import {useSelector} from 'react-redux';
+import mdmModule from '@reltio/mdm-module';
+import {
+    DashboardConfigFilter,
+    findAttributeTypeByUri,
+    getSpecialAttrTypeByFieldName,
+    SearchFilter
+} from '@reltio/mdm-sdk';
+import {always, andThen, otherwise, pipe, when, unless} from 'ramda';
+import {
+    getFacetFieldName,
+    getFiltersForFacet,
+    requestFacets,
+    requestOtherValues,
+    resolveFacetLabels,
+    localizeFacetValues
+} from '../services/facets';
+import {ChartData, RequestStates, SearchFiltersContext} from '@reltio/components';
+import {GlobalSearchRequestOptions} from '../types/SearchOptions';
+import {convertSearchFilterToDashboardConfigFilter} from '../services/filters';
+
+type Props = {
+    filters: DashboardConfigFilter[];
+    attributeUri: string;
+    pageSize: number;
+    orderType?: string;
+    options?: {
+        showOthers: boolean;
+    };
+};
+
+export const useFacetRequest = ({
+    filters: facetFilters,
+    attributeUri,
+    pageSize,
+    orderType = 'reversedCount',
+    options
+}: Props) => {
+    const [data, setData] = useState<ChartData[]>([]);
+    const [requestState, setRequestState] = useState<RequestStates>(RequestStates.INIT);
+    const searchFilters = useContext<SearchFilter[]>(SearchFiltersContext);
+    const facetAndSpecialFilters = useMemo(
+        () => searchFilters.map(convertSearchFilterToDashboardConfigFilter).concat(facetFilters || []),
+        [searchFilters, facetFilters]
+    );
+    const metadata = useSelector(mdmModule.selectors.getMetadata);
+    const {globalFilter, activityFilter}: GlobalSearchRequestOptions = useSelector(
+        mdmModule.selectors.getGlobalSearchRequestOptions
+    );
+    const attributePresentations = useSelector(mdmModule.selectors.getAttributePresentations);
+    const hasAttrPresentation = !!attributePresentations?.[attributeUri];
+    const searchByOv: boolean = useSelector(mdmModule.selectors.getShowSearchByOv);
+    const showOthers: boolean = options?.showOthers;
+    const onError = (error) => {
+        console.error(error); // eslint-disable-line
+        setRequestState(RequestStates.ERROR);
+        setData([]);
+    };
+    const loadData = useCallback(() => {
+        setRequestState(RequestStates.LOADING);
+        const filters = getFiltersForFacet(attributeUri, facetAndSpecialFilters);
+        const fieldName = getFacetFieldName(attributeUri);
+        const attrType = getSpecialAttrTypeByFieldName(fieldName) || findAttributeTypeByUri(metadata, attributeUri);
+        const onRequestFinished = (data: ChartData[]) => {
+            setRequestState(RequestStates.LOADED);
+            setData(data);
+        };
+
+        if (!attrType) {
+            onError('Configuration is incorrect');
+            return;
+        }
+
+        const getData = pipe(
+            requestFacets,
+            andThen(resolveFacetLabels(metadata, attrType)),
+            andThen(unless(always(hasAttrPresentation), localizeFacetValues)),
+            andThen(
+                when(
+                    always(showOthers),
+                    requestOtherValues({attribute: fieldName, filters, globalFilter, searchByOv, activityFilter})
+                )
+            ),
+            andThen(onRequestFinished),
+            otherwise(onError)
+        );
+
+        getData({attribute: fieldName, filters, globalFilter, searchByOv, activityFilter, pageSize, orderType});
+    }, [
+        setRequestState,
+        attributeUri,
+        metadata,
+        showOthers,
+        facetAndSpecialFilters,
+        globalFilter,
+        searchByOv,
+        activityFilter,
+        pageSize,
+        orderType,
+        hasAttrPresentation
+    ]);
+
+    const refreshAction = () => {
+        try {
+            loadData();
+        } catch (e) {
+            onError(e);
+        }
+    };
+
+    useEffect(() => {
+        refreshAction();
+    }, [loadData]);
+
+    return {state: requestState, data, reload: refreshAction};
+};

package/src/hooks/useFilteredEntitiesRequest.ts

@@ -0,0 +1,57 @@
+import {useCallback, useContext, useEffect, useMemo, useState} from 'react';
+import {RequestStates, SearchFiltersContext} from '@reltio/components';
+import {DashboardConfigFilter, getFilteredEntities, getTotals, SearchFilter} from '@reltio/mdm-sdk';
+import {EntityData} from '../types/EntityData';
+import {convertSearchFilterToDashboardConfigFilter} from '../services/filters';
+
+type Props = {
+    filters: DashboardConfigFilter[];
+    offset: number;
+    max: number;
+};
+
+export const useFilteredEntitiesRequest = ({filters, max, offset}: Props) => {
+    const [data, setData] = useState<EntityData[]>([]);
+    const [total, setTotal] = useState<number>(0);
+    const [requestState, setRequestState] = useState<RequestStates>(RequestStates.INIT);
+
+    const searchFilters = useContext<SearchFilter[]>(SearchFiltersContext);
+    const allFilters = useMemo(
+        () => searchFilters.map(convertSearchFilterToDashboardConfigFilter).concat(filters || []),
+        [searchFilters, filters]
+    );
+
+    const onError = (error) => {
+        console.error(error); // eslint-disable-line
+        setRequestState(RequestStates.ERROR);
+        setData([]);
+        setTotal(0);
+    };
+
+    const loadData = useCallback(() => {
+        setRequestState(RequestStates.LOADING);
+
+        Promise.all([getFilteredEntities(allFilters, {max, offset}), getTotals(allFilters, {max, offset})])
+            .then((results) => {
+                const [entities, {total}] = results;
+                setData(entities || []);
+                setTotal(total);
+                setRequestState(RequestStates.LOADED);
+            })
+            .catch(onError);
+    }, [allFilters, max, offset]);
+
+    const refreshAction = () => {
+        try {
+            loadData();
+        } catch (e) {
+            onError(e);
+        }
+    };
+
+    useEffect(() => {
+        refreshAction();
+    }, [loadData]);
+
+    return {state: requestState, data, reload: refreshAction, total};
+};