@reltio/interactions 1.4.1585 → 1.4.1586-mui5

package/src/InteractionsTableView/helpers/__tests__/tableHelper.test.js

@@ -0,0 +1,300 @@
+import {
+    ACTORS_COLUMN_ID,
+    ATTRIBUTES_COLUMN_ID,
+    getColumnsData,
+    getRowsPerPageOptions,
+    INTERACTION_TYPE_COLUMN_ID,
+    MAX_ATTRIBUTES_TO_SHOW
+} from '../tableHelpers';
+import {DataTypes, makeCompositeFilterOption} from '@reltio/mdm-sdk';
+
+describe('get rows per page options scenarios', () => {
+    it('should return rows per page options include default', () => {
+        expect(getRowsPerPageOptions(15)).toEqual([10, 15, 25, 50, 100]);
+    });
+    it('should not contain duplicates', () => {
+        expect(getRowsPerPageOptions(25)).toEqual([10, 25, 50, 100]);
+    });
+});
+
+describe('get column data scenarios', () => {
+    const interactionTypes = [
+        {
+            uri: 'configuration/interactionTypes/Type1',
+            attributes: [
+                {
+                    type: 'String',
+                    uri: 'configuration/interactionTypes/Type/attributes/String',
+                    name: 'String',
+                    label: 'String'
+                }
+            ],
+            label: 'Type 1',
+            memberTypes: [
+                {
+                    name: 'HCP',
+                    label: 'HCP'
+                }
+            ]
+        },
+        {
+            uri: 'configuration/interactionTypes/Type2',
+            attributes: [],
+            label: 'Type 2',
+            memberTypes: [
+                {
+                    name: 'HCO',
+                    label: 'HCO'
+                }
+            ]
+        }
+    ];
+    const metadata = {
+        interactionTypes
+    };
+    const config = {
+        attributes: {
+            'configuration/interactionTypes/1': [
+                'configuration/interactionTypes/1/attributes/ATTR_NAME1',
+                'configuration/interactionTypes/1/attributes/ATTR_NAME2'
+            ]
+        }
+    };
+
+    it('should return date, actors and attributes columns if current interaction type is defined', () => {
+        const columnsData = getColumnsData(metadata, config, interactionTypes, 'configuration/interactionTypes/Type1');
+        expect(columnsData).toEqual([
+            {
+                id: 'timestamp',
+                label: 'Date',
+                dataTypeDefinition: {
+                    type: DataTypes.TYPE_TIMESTAMP
+                },
+                hideable: false
+            },
+            {
+                id: ACTORS_COLUMN_ID,
+                label: 'Actors',
+                sortable: false,
+                dataTypeDefinition: {
+                    type: DataTypes.TYPE_STRING
+                },
+                filterOptions: [
+                    {value: 'equals'},
+                    {value: 'not equals'},
+                    {value: 'hasAll'},
+                    {value: 'in.file'},
+                    {value: 'not.in.file'},
+                    {
+                        value: makeCompositeFilterOption('types', 'equals'),
+                        label: 'type equals',
+                        dataTypeDefinition: {
+                            type: 'Select',
+                            options: [{value: 'HCP', label: 'HCP'}]
+                        }
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'not equals'),
+                        label: 'type not',
+                        dataTypeDefinition: {
+                            type: 'Select',
+                            options: [{value: 'HCP', label: 'HCP'}]
+                        }
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'hasAll'),
+                        label: 'type has all',
+                        dataTypeDefinition: {
+                            type: 'Select',
+                            options: [{value: 'HCP', label: 'HCP'}]
+                        }
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'in.file'),
+                        label: 'type in file'
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'not.in.file'),
+                        label: 'type not in file'
+                    }
+                ]
+            },
+            {
+                id: 'attributes.String',
+                label: 'String',
+                dataTypeDefinition: {
+                    type: 'String',
+                    uri: 'configuration/interactionTypes/Type/attributes/String',
+                    name: 'String'
+                }
+            }
+        ]);
+    });
+
+    it('should return date, actors, type and attributes columns if current interaction type is undefined', () => {
+        const columnsData = getColumnsData(metadata, config, interactionTypes);
+        expect(columnsData).toEqual([
+            {
+                id: 'timestamp',
+                label: 'Date',
+                dataTypeDefinition: {
+                    type: DataTypes.TYPE_TIMESTAMP
+                },
+                hideable: false
+            },
+            {
+                id: INTERACTION_TYPE_COLUMN_ID,
+                label: 'Interaction type',
+                sortable: false,
+                filterOptions: [{value: 'equals'}, {value: 'not equals'}],
+                dataTypeDefinition: {
+                    type: DataTypes.TYPE_SELECT,
+                    options: interactionTypes.map(({uri, label}) => ({value: uri, label}))
+                }
+            },
+            {
+                id: ACTORS_COLUMN_ID,
+                label: 'Actors',
+                sortable: false,
+                dataTypeDefinition: {
+                    type: DataTypes.TYPE_STRING
+                },
+                filterOptions: [
+                    {value: 'equals'},
+                    {value: 'not equals'},
+                    {value: 'hasAll'},
+                    {value: 'in.file'},
+                    {value: 'not.in.file'},
+                    {
+                        value: makeCompositeFilterOption('types', 'equals'),
+                        label: 'type equals',
+                        dataTypeDefinition: {
+                            type: 'Select',
+                            options: [
+                                {value: 'HCP', label: 'HCP'},
+                                {value: 'HCO', label: 'HCO'}
+                            ]
+                        }
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'not equals'),
+                        label: 'type not',
+                        dataTypeDefinition: {
+                            type: 'Select',
+                            options: [
+                                {value: 'HCP', label: 'HCP'},
+                                {value: 'HCO', label: 'HCO'}
+                            ]
+                        }
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'hasAll'),
+                        label: 'type has all',
+                        dataTypeDefinition: {
+                            type: 'Select',
+                            options: [
+                                {value: 'HCP', label: 'HCP'},
+                                {value: 'HCO', label: 'HCO'}
+                            ]
+                        }
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'in.file'),
+                        label: 'type in file'
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'not.in.file'),
+                        label: 'type not in file'
+                    }
+                ]
+            },
+            {
+                id: ATTRIBUTES_COLUMN_ID,
+                label: 'Attributes',
+                sortable: false,
+                filterable: false,
+                maxAttrsToShow: MAX_ATTRIBUTES_TO_SHOW,
+                attrsToShow: config.attributes
+            }
+        ]);
+    });
+
+    it('should return date, actors, type and attributes columns if interationTypes is missing in metadata', () => {
+        const columnsData = getColumnsData({}, config, []);
+        expect(columnsData).toEqual([
+            {
+                id: 'timestamp',
+                label: 'Date',
+                dataTypeDefinition: {
+                    type: DataTypes.TYPE_TIMESTAMP
+                },
+                hideable: false
+            },
+            {
+                id: INTERACTION_TYPE_COLUMN_ID,
+                label: 'Interaction type',
+                sortable: false,
+                filterOptions: [{value: 'equals'}, {value: 'not equals'}],
+                dataTypeDefinition: {
+                    type: DataTypes.TYPE_SELECT,
+                    options: []
+                }
+            },
+            {
+                id: ACTORS_COLUMN_ID,
+                label: 'Actors',
+                sortable: false,
+                dataTypeDefinition: {
+                    type: DataTypes.TYPE_STRING
+                },
+                filterOptions: [
+                    {value: 'equals'},
+                    {value: 'not equals'},
+                    {value: 'hasAll'},
+                    {value: 'in.file'},
+                    {value: 'not.in.file'},
+                    {
+                        value: makeCompositeFilterOption('types', 'equals'),
+                        label: 'type equals',
+                        dataTypeDefinition: {
+                            type: 'Select',
+                            options: []
+                        }
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'not equals'),
+                        label: 'type not',
+                        dataTypeDefinition: {
+                            type: 'Select',
+                            options: []
+                        }
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'hasAll'),
+                        label: 'type has all',
+                        dataTypeDefinition: {
+                            type: 'Select',
+                            options: []
+                        }
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'in.file'),
+                        label: 'type in file'
+                    },
+                    {
+                        value: makeCompositeFilterOption('types', 'not.in.file'),
+                        label: 'type not in file'
+                    }
+                ]
+            },
+            {
+                id: ATTRIBUTES_COLUMN_ID,
+                label: 'Attributes',
+                sortable: false,
+                filterable: false,
+                maxAttrsToShow: MAX_ATTRIBUTES_TO_SHOW,
+                attrsToShow: config.attributes
+            }
+        ]);
+    });
+});

package/src/InteractionsTableView/helpers/filtersHelpers.ts

@@ -0,0 +1,18 @@
+import {FilterBuilder, Maybe} from '@reltio/mdm-sdk';
+import {buildColumnsFilter, ColumnData, ColumnFilter} from '@reltio/components';
+
+const createInteractionTypeFilter = (value) => `equals(type,'${value}')`;
+
+const buildInteractionsFilter = (
+    currentInteractionType: string,
+    filters: Record<string, ColumnFilter>,
+    columnsData: ColumnData[]
+) => {
+    const currentTypeClause = Maybe.fromNull(currentInteractionType).map(createInteractionTypeFilter).orSome('');
+
+    const filtersClause = buildColumnsFilter(columnsData, filters);
+
+    return new FilterBuilder().addClause(currentTypeClause).addClause(filtersClause).build();
+};
+
+export {buildInteractionsFilter};

package/src/InteractionsTableView/helpers/tableHelpers.ts

@@ -0,0 +1,157 @@
+import {
+    attributeUriToSearchUri,
+    DataTypes,
+    FilterOptions,
+    getAttrDataTypeDefinition,
+    getInteractionAttributesFromMetadata,
+    getInteractionType,
+    InteractionType,
+    makeCompositeFilterOption
+} from '@reltio/mdm-sdk';
+import {adjust, assoc, chain, concat, map, pipe, pluck, prop, propEq, reject, subtract, uniqBy} from 'ramda';
+import i18n from 'ui-i18n';
+
+const ROWS_PER_PAGE_OPTIONS = [10, 25, 50, 100];
+const getRowsPerPageOptions = (defaultRowsPerPage: number) =>
+    ROWS_PER_PAGE_OPTIONS.filter((option) => option !== defaultRowsPerPage)
+        .concat(defaultRowsPerPage)
+        .sort(subtract);
+
+const INTERACTION_TYPE_COLUMN_ID = 'type';
+const ACTORS_COLUMN_ID = 'members';
+const ATTRIBUTES_COLUMN_ID = 'attributes';
+
+const MAX_ATTRIBUTES_TO_SHOW = 7;
+
+const DEFAULT_COLUMNS_DATA = [
+    {
+        id: 'timestamp',
+        label: 'Date',
+        dataTypeDefinition: {
+            type: DataTypes.TYPE_TIMESTAMP
+        },
+        hideable: false
+    },
+    {
+        id: INTERACTION_TYPE_COLUMN_ID,
+        label: 'Interaction type',
+        sortable: false,
+        filterOptions: [{value: FilterOptions.EQUALS}, {value: FilterOptions.NOT_EQUALS}]
+    },
+    {
+        id: ACTORS_COLUMN_ID,
+        label: 'Actors',
+        sortable: false,
+        dataTypeDefinition: {
+            type: DataTypes.TYPE_STRING
+        }
+    },
+    {
+        id: ATTRIBUTES_COLUMN_ID,
+        label: 'Attributes',
+        sortable: false,
+        filterable: false,
+        maxAttrsToShow: MAX_ATTRIBUTES_TO_SHOW
+    }
+];
+
+const DEFAULT_COLUMNS = pluck('id', DEFAULT_COLUMNS_DATA);
+const ALL_TYPES_COLUMNS = [INTERACTION_TYPE_COLUMN_ID, ATTRIBUTES_COLUMN_ID];
+
+const getColumnsDataFromInteractionAttributes = pipe(
+    map((attr) => ({
+        id: attributeUriToSearchUri(attr.uri),
+        label: attr.label,
+        dataTypeDefinition: getAttrDataTypeDefinition(attr)
+    })),
+    uniqBy(prop('id'))
+);
+
+const getInteractionColumnDataType = (interactionTypes) => ({
+    type: DataTypes.TYPE_SELECT,
+    options: interactionTypes.map(({uri, label}) => ({value: uri, label}))
+});
+
+const getActorTypesOptions = pipe(
+    chain(({memberTypes}) => memberTypes.map(({name, label}) => ({label, value: name}))),
+    uniqBy(prop('value'))
+);
+
+const getActorsColumnFilterOptions = (interactionTypes: Array<InteractionType>) => {
+    const typeFilterDataType = {
+        type: DataTypes.TYPE_SELECT,
+        options: getActorTypesOptions(interactionTypes)
+    };
+    const makeTypeOption = makeCompositeFilterOption('types');
+    return [
+        {value: FilterOptions.EQUALS},
+        {value: FilterOptions.NOT_EQUALS},
+        {value: FilterOptions.HAS_ALL},
+        {value: FilterOptions.IN_FILE},
+        {value: FilterOptions.NOT_IN_FILE},
+        {
+            value: makeTypeOption(FilterOptions.EQUALS),
+            label: i18n.text('type equals'),
+            dataTypeDefinition: typeFilterDataType
+        },
+        {
+            value: makeTypeOption(FilterOptions.NOT_EQUALS),
+            label: i18n.text('type not'),
+            dataTypeDefinition: typeFilterDataType
+        },
+        {
+            value: makeTypeOption(FilterOptions.HAS_ALL),
+            label: i18n.text('type has all'),
+            dataTypeDefinition: typeFilterDataType
+        },
+        {
+            value: makeTypeOption(FilterOptions.IN_FILE),
+            label: i18n.text('type in file')
+        },
+        {
+            value: makeTypeOption(FilterOptions.NOT_IN_FILE),
+            label: i18n.text('type not in file')
+        }
+    ];
+};
+
+const updateColumnData = (columnId, updateFn) => (columnsData) =>
+    adjust(columnsData.findIndex(propEq('id', columnId)), updateFn, columnsData);
+
+const updateInteractionTypeColumn = (interactionTypes) =>
+    updateColumnData(
+        INTERACTION_TYPE_COLUMN_ID,
+        assoc('dataTypeDefinition', getInteractionColumnDataType(interactionTypes))
+    );
+
+const updateActorsColumn = (interactionTypes) =>
+    updateColumnData(ACTORS_COLUMN_ID, assoc('filterOptions', getActorsColumnFilterOptions(interactionTypes)));
+
+const updateAttributesColumn = (attributes) => updateColumnData(ATTRIBUTES_COLUMN_ID, assoc('attrsToShow', attributes));
+
+const getColumnsData = (metadata, config, interactionTypes, currentInteractionType) => {
+    return currentInteractionType
+        ? pipe(
+            getInteractionAttributesFromMetadata,
+            getColumnsDataFromInteractionAttributes,
+            concat(DEFAULT_COLUMNS_DATA),
+            reject(({id}) => ALL_TYPES_COLUMNS.includes(id)),
+            updateActorsColumn([getInteractionType(metadata, currentInteractionType)])
+        )(metadata, currentInteractionType)
+        : pipe(
+            updateAttributesColumn(config.attributes),
+            updateInteractionTypeColumn(interactionTypes),
+            updateActorsColumn(metadata.interactionTypes || [])
+        )(DEFAULT_COLUMNS_DATA);
+};
+
+export {
+    getRowsPerPageOptions,
+    DEFAULT_COLUMNS,
+    getColumnsData,
+    INTERACTION_TYPE_COLUMN_ID,
+    ACTORS_COLUMN_ID,
+    ATTRIBUTES_COLUMN_ID,
+    ALL_TYPES_COLUMNS,
+    MAX_ATTRIBUTES_TO_SHOW
+};

package/src/InteractionsTableView/hooks/useInteractions.ts

@@ -0,0 +1,45 @@
+import {useState, useEffect} from 'react';
+import {getInteractions} from '@reltio/mdm-sdk';
+import {Sorting, useSafePromise} from '@reltio/components';
+
+type Props = {
+    entityUri: string;
+    sorting: Sorting;
+    page: number;
+    rowsPerPage: number;
+    filter: string;
+    enabled: boolean;
+};
+
+const useInteractions = ({entityUri, filter, sorting, page, rowsPerPage, enabled}: Props) => {
+    const [isLoading, setIsLoading] = useState(false);
+    const [total, setTotal] = useState(0);
+    const [interactions, setInteractions] = useState([]);
+    const safePromise = useSafePromise();
+
+    useEffect(() => {
+        if (enabled) {
+            setIsLoading(true);
+            safePromise(
+                getInteractions({
+                    entityUri: entityUri,
+                    offset: page * rowsPerPage,
+                    max: rowsPerPage,
+                    filter,
+                    sort: sorting.field,
+                    order: sorting.order
+                })
+            )
+                .then(({totalFetched, interactions = []}) => {
+                    setTotal(totalFetched);
+                    setInteractions(interactions);
+                })
+                .then((_) => setIsLoading(false))
+                .catch((_) => setIsLoading(false));
+        }
+    }, [entityUri, filter, sorting.field, sorting.order, page, rowsPerPage, enabled]); // eslint-disable-line
+
+    return {isLoading, interactions, total};
+};
+
+export default useInteractions;