@reltio/profile 1.4.1585 → 1.4.1586-mui5

package/src/components/ProfileTableAttributeView/components/TableAttributeEditableContent/__tests__/TableAttributeEditableContent.test.tsx

@@ -0,0 +1,450 @@
+import React, {ContextType} from 'react';
+import {mount} from 'enzyme';
+import * as reactRedux from 'react-redux';
+import {ConfigPermissions, ErrorType, Mode, ProfileViewTypes} from '@reltio/mdm-sdk';
+import Button from '@mui/material/Button';
+import {TableAttributeContext} from '../../../contexts/TableAttributeContext';
+import {AttributeEditing} from '../../AttributeEditing/AttributeEditing';
+import {TableAttributeEditableContent} from '../TableAttributeEditableContent';
+
+jest.mock('@reltio/components', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/components'),
+    useActionsHook: jest.fn().mockReturnValue(() => () => {})
+}));
+jest.mock('../../AttributeEditing/AttributeEditing', () => ({
+    AttributeEditing: () => null
+}));
+
+const defaultConfig = {
+    attributeUri: 'configuration/entityTypes/HCA/attributes/Communication',
+    caption: 'Attributes View',
+    max: 15,
+    id: 'viewId',
+    class: ProfileViewTypes.AttributeTable
+};
+
+const defaultProps = {
+    config: defaultConfig,
+    editingValues: [],
+    modifiedValues: [],
+    onChangeAttribute: jest.fn(),
+    onDeleteAttribute: jest.fn(),
+    onAdd: jest.fn(),
+    onCancel: jest.fn(),
+    onApply: jest.fn(),
+    onStartEditing: jest.fn(),
+    checkHasChanges: jest.fn(),
+    highlightedError: null,
+    highlightedAttributeError: null,
+    onReset: jest.fn()
+};
+
+const defaultAttributeType = {
+    uri: 'configuration/entityTypes/HCA/attributes/Communication'
+};
+
+const setUp = ({props = defaultProps, contextValue = {attributeType: defaultAttributeType}} = {}) => {
+    return mount(
+        <TableAttributeContext.Provider value={contextValue as ContextType<typeof TableAttributeContext>}>
+            <TableAttributeEditableContent {...props} />
+        </TableAttributeContext.Provider>
+    );
+};
+
+describe('TableAttributeEditableContent tests', () => {
+    let store;
+
+    beforeEach(() => {
+        store = {
+            profile: {
+                mode: Mode.Editing,
+                entity: {
+                    uri: 'entities/123'
+                },
+                errors: []
+            }
+        };
+        jest.spyOn(reactRedux, 'useSelector').mockImplementation((selector) => selector(store));
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should not render add button if editingValues is empty array', () => {
+        const editingValues = [
+            {
+                type: 'configuration/entityTypes/HCA/attributes/Communication',
+                uri: 'entities/1ROuA3w3/attributes/Communication/uri$$PE3yAiC7lAV58Dtn1677752925147',
+                value: {
+                    ChannelName: [
+                        {
+                            ov: true,
+                            type: 'configuration/entityTypes/HCA/attributes/Communication/attributes/ChannelName',
+                            uri: 'entities/1ROuA3w3/attributes/Communication/uri$$PE3yAiC7lAV58Dtn1677752925147/ChannelName/uri$$rq85hc1YMfTouVVB1677752925149',
+                            value: ''
+                        }
+                    ]
+                }
+            }
+        ];
+
+        const props = {...defaultProps, editingValues};
+        const component = setUp({props});
+        expect(component.find(Button)).toHaveLength(0);
+    });
+
+    it('should not render add button if attributeType has not permission for create', () => {
+        const attributeType = {...defaultAttributeType, access: []};
+        const contextValue = {attributeType};
+        const component = setUp({contextValue});
+        expect(component.find(Button)).toHaveLength(0);
+    });
+
+    it('should not render add button if config has not permission for create', () => {
+        const config = {...defaultConfig, [ConfigPermissions.CREATE]: {roles: []}};
+        const props = {...defaultProps, config};
+        const component = setUp({props});
+        expect(component.find(Button)).toHaveLength(0);
+    });
+
+    it('should render add button if there is all permissions and no editing values', () => {
+        const component = setUp();
+        expect(component.find(Button)).toHaveLength(1);
+        expect(component.find(Button).find('.buttonLabel').text()).toBe('Add');
+    });
+
+    it('should render EditingAttribute for each editing value correctly', () => {
+        const editingValues = [
+            {
+                type: 'configuration/entityTypes/HCA/attributes/Communication',
+                uri: 'entities/123/attributes/Communication/uri$$2',
+                value: {}
+            },
+            {
+                type: 'configuration/entityTypes/HCA/attributes/Communication',
+                uri: 'entities/123/attributes/Communication/uri$$3',
+                value: {}
+            }
+        ];
+
+        const {onChangeAttribute, onDeleteAttribute, onCancel, onApply} = defaultProps;
+        const checkHasChanges = jest.fn().mockReturnValue(true);
+        const props = {...defaultProps, editingValues, checkHasChanges};
+        const component = setUp({props});
+
+        expect(component.find(AttributeEditing)).toHaveLength(2);
+        component.find(AttributeEditing).forEach((node, idx) => {
+            expect(node.props()).toEqual({
+                attributeValue: editingValues[idx],
+                onChangeAttribute,
+                onDeleteAttribute,
+                onCancel,
+                onApply,
+                hasChanges: true
+            });
+        });
+    });
+
+    it('should call onReset when component unmount', () => {
+        const component = setUp();
+        component.unmount();
+        expect(defaultProps.onReset).toHaveBeenCalled();
+    });
+
+    describe('useExpandAttributes behaviour', () => {
+        describe('expanding attribute if attribute type error changed', () => {
+            it('should call onStartEditing for first modified value if errors has attribute type error with missed type and modifiedValues exist only one value', () => {
+                store.profile.errors = [
+                    {
+                        type: ErrorType.missed,
+                        attributeTypeUri: 'configuration/entityTypes/HCA/attributes/Communication',
+                        parentUri: store.profile.entity.uri,
+                        uri: ''
+                    }
+                ];
+
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$2',
+                        value: {}
+                    }
+                ];
+                const props = {...defaultProps, modifiedValues};
+                setUp({props});
+                const {onStartEditing} = props;
+                expect(onStartEditing).toHaveBeenCalledTimes(1);
+                expect(onStartEditing).toHaveBeenCalledWith(modifiedValues[0]);
+            });
+
+            it('should not call onStartEditing if errors has attribute type error, but its type is not missed', () => {
+                store.profile.errors = [
+                    {
+                        type: 'other error type',
+                        attributeTypeUri: 'configuration/entityTypes/HCA/attributes/Communication',
+                        parentUri: store.profile.entity.uri,
+                        uri: ''
+                    }
+                ];
+
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$2',
+                        value: {}
+                    }
+                ];
+                const props = {...defaultProps, modifiedValues};
+                setUp({props});
+                const {onStartEditing} = props;
+                expect(onStartEditing).not.toHaveBeenCalled();
+            });
+
+            it('should not call onStartEditing if errors has attribute type error, but modifiedValues has length is not equals 1', () => {
+                store.profile.errors = [
+                    {
+                        type: ErrorType.missed,
+                        attributeTypeUri: 'configuration/entityTypes/HCA/attributes/Communication',
+                        parentUri: store.profile.entity.uri,
+                        uri: ''
+                    }
+                ];
+
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$2',
+                        value: {}
+                    },
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$3',
+                        value: {}
+                    }
+                ];
+                const props = {...defaultProps, modifiedValues};
+                setUp({props});
+                const {onStartEditing} = props;
+                expect(onStartEditing).not.toHaveBeenCalled();
+            });
+        });
+
+        describe('expanding attributes if errors changing', () => {
+            it('should call onStartEditing for each modified value that has error of attribute', () => {
+                store.profile.errors = [
+                    {
+                        type: ErrorType.missed,
+                        attributeTypeUri:
+                            'configuration/entityTypes/HCA/attributes/Communication/attributes/CommunicationValue',
+                        parentUri: 'entities/123/attributes/Communication/uri$$1',
+                        uri: ''
+                    },
+                    {
+                        type: ErrorType.missed,
+                        attributeTypeUri:
+                            'configuration/entityTypes/HCA/attributes/Communication/attributes/Nested/attributes/Value',
+                        parentUri: 'entities/123/attributes/Communication/uri$$2/Nested/uri$$4',
+                        uri: ''
+                    },
+                    {
+                        type: ErrorType.missed,
+                        attributeTypeUri:
+                            'configuration/entityTypes/HCA/attributes/ContactPreference/attributes/PreferenceConsentInd',
+                        parentUri: 'entities/123/attributes/ContactPreference/uri$$3',
+                        uri: ''
+                    },
+                    {
+                        type: 'some error type',
+                        attributeTypeUri: 'configuration/entityTypes/HCA/attributes/Communication',
+                        parentUri: 'entities/123',
+                        uri: 'entities/123/attributes/Communication/uri$$4'
+                    }
+                ];
+
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$1',
+                        value: {}
+                    },
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$2',
+                        value: {}
+                    },
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$4',
+                        value: {}
+                    }
+                ];
+                const props = {...defaultProps, modifiedValues};
+                setUp({props});
+                const {onStartEditing} = props;
+                expect(onStartEditing).toHaveBeenCalledTimes(3);
+                expect(onStartEditing).toHaveBeenNthCalledWith(1, modifiedValues[0]);
+                expect(onStartEditing).toHaveBeenNthCalledWith(2, modifiedValues[1]);
+                expect(onStartEditing).toHaveBeenNthCalledWith(3, modifiedValues[2]);
+            });
+        });
+
+        describe('expanding attribute if highlightedError appears', () => {
+            it('should call onStartEditing for first modified value if highlightedError has missed type and modifiedValues exist only one value', () => {
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$2',
+                        value: {}
+                    }
+                ];
+
+                const highlightedError = {
+                    type: ErrorType.missed,
+                    attributeTypeUri: 'configuration/entityTypes/HCA/attributes/Communication',
+                    parentUri: store.profile.entity.uri,
+                    uri: ''
+                };
+
+                const props = {...defaultProps, modifiedValues, highlightedError};
+                setUp({props});
+
+                const {onStartEditing} = props;
+                expect(onStartEditing).toHaveBeenCalledTimes(1);
+                expect(onStartEditing).toHaveBeenCalledWith(modifiedValues[0]);
+            });
+
+            it('should not call onStartEditing if highlightedError exists, but its type is not missed', () => {
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$2',
+                        value: {}
+                    }
+                ];
+
+                const highlightedError = {
+                    type: 'other error type',
+                    attributeTypeUri: 'configuration/entityTypes/HCA/attributes/Communication',
+                    parentUri: store.profile.entity.uri,
+                    uri: ''
+                };
+
+                const props = {...defaultProps, modifiedValues, highlightedError};
+                setUp({props});
+
+                const {onStartEditing} = props;
+                expect(onStartEditing).not.toHaveBeenCalled();
+            });
+
+            it('should call onStartEditing for first modified value if highlightedError has missed type, but modifiedValues has length is not equals 1', () => {
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$1',
+                        value: {}
+                    },
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$2',
+                        value: {}
+                    }
+                ];
+
+                const highlightedError = {
+                    type: ErrorType.missed,
+                    attributeTypeUri: 'configuration/entityTypes/HCA/attributes/Communication',
+                    parentUri: store.profile.entity.uri,
+                    uri: ''
+                };
+
+                const props = {...defaultProps, modifiedValues, highlightedError};
+                setUp({props});
+
+                const {onStartEditing} = props;
+                expect(onStartEditing).not.toHaveBeenCalled();
+            });
+        });
+
+        describe('expanding attribute if highlightedAttributeError appears', () => {
+            it('should call onStartEditing for top level parent of subattribute with error', () => {
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$1',
+                        value: {}
+                    },
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$2',
+                        value: {}
+                    }
+                ];
+
+                const highlightedAttributeError = {
+                    type: ErrorType.missed,
+                    attributeTypeUri:
+                        'configuration/entityTypes/HCA/attributes/Communication/attributes/CommunicationValue',
+                    parentUri: 'entities/123/attributes/Communication/uri$$2',
+                    uri: ''
+                };
+
+                const props = {...defaultProps, modifiedValues, highlightedAttributeError};
+                setUp({props});
+
+                const {onStartEditing} = props;
+                expect(onStartEditing).toHaveBeenCalledTimes(1);
+                expect(onStartEditing).toHaveBeenCalledWith(modifiedValues[1]);
+            });
+
+            it('should call onStartEditing for top level parent of subattribute with error with deep nesting', () => {
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$1',
+                        value: {}
+                    }
+                ];
+
+                const highlightedAttributeError = {
+                    type: ErrorType.missed,
+                    attributeTypeUri:
+                        'configuration/entityTypes/HCA/attributes/Communication/attributes/NestedValue/attributes/Name',
+                    parentUri: 'entities/123/attributes/Communication/uri$$1/NestedValue/uri$$2',
+                    uri: ''
+                };
+
+                const props = {...defaultProps, modifiedValues, highlightedAttributeError};
+                setUp({props});
+
+                const {onStartEditing} = props;
+                expect(onStartEditing).toHaveBeenCalledTimes(1);
+                expect(onStartEditing).toHaveBeenCalledWith(modifiedValues[0]);
+            });
+
+            it('should call onStartEditing for attribute with own error', () => {
+                const modifiedValues = [
+                    {
+                        type: 'configuration/entityTypes/HCA/attributes/Communication',
+                        uri: 'entities/123/attributes/Communication/uri$$1',
+                        value: {}
+                    }
+                ];
+
+                const highlightedAttributeError = {
+                    type: 'some error type',
+                    attributeTypeUri: 'configuration/entityTypes/HCA/attributes/Communication',
+                    parentUri: 'entities/123',
+                    uri: 'entities/123/attributes/Communication/uri$$1'
+                };
+
+                const props = {...defaultProps, modifiedValues, highlightedAttributeError};
+                setUp({props});
+
+                const {onStartEditing} = props;
+                expect(onStartEditing).toHaveBeenCalledTimes(1);
+                expect(onStartEditing).toHaveBeenCalledWith(modifiedValues[0]);
+            });
+        });
+    });
+});

package/src/components/ProfileTableAttributeView/components/TableAttributeEditableContent/hooks/__tests__/useExpandAttributes.test.tsx

@@ -0,0 +1,92 @@
+import React from 'react';
+import {renderHook} from '@testing-library/react-hooks';
+import * as reactRedux from 'react-redux';
+import {AttributeType, ErrorType} from '@reltio/mdm-sdk';
+import {useActionsHook} from '@reltio/components';
+import {TableAttributeContext} from '../../../../contexts/TableAttributeContext';
+import {useExpandAttributes} from '../useExpandAttributes';
+import {profile} from '@reltio/mdm-module';
+import {AnyAction} from 'redux';
+
+jest.mock('@reltio/components', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/components'),
+    useActionsHook: jest.fn()
+}));
+
+describe('useExpandAttributes behaviour', () => {
+    let store;
+
+    beforeEach(() => {
+        store = {
+            profile: {
+                entity: {
+                    uri: 'entities/123'
+                },
+                errors: []
+            }
+        };
+        jest.spyOn(reactRedux, 'useSelector').mockImplementation((selector) => selector(store));
+        (useActionsHook as jest.Mock).mockReturnValue(() => () => {});
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should update errors only after save profile', () => {
+        let listenToActions;
+        const triggerAction = (action: AnyAction) => listenToActions(action, store);
+        (useActionsHook as jest.Mock).mockReturnValue((listener) => {
+            listenToActions = listener;
+            return () => {};
+        });
+
+        const createErrors = () => {
+            const errors = [
+                {
+                    type: ErrorType.missed,
+                    attributeTypeUri:
+                        'configuration/entityTypes/HCA/attributes/Communication/attributes/CommunicationValue',
+                    parentUri: 'entities/123/attributes/Communication/uri$$1',
+                    uri: ''
+                }
+            ];
+            return errors;
+        };
+
+        store.profile.errors = createErrors();
+
+        const attributeType = {uri: 'configuration/entityTypes/HCA/attributes/Communication'} as AttributeType;
+        const contextValue = {attributeType} as any;
+        const modifiedValues = [
+            {
+                type: 'configuration/entityTypes/HCA/attributes/Communication',
+                uri: 'entities/123/attributes/Communication/uri$$1',
+                value: {}
+            }
+        ];
+
+        const props = {
+            onStartEditing: jest.fn(),
+            highlightedError: null,
+            highlightedAttributeError: null,
+            modifiedValues
+        };
+
+        const wrapper = ({children}: {children?: React.ReactNode}) => (
+            <TableAttributeContext.Provider value={contextValue}>{children}</TableAttributeContext.Provider>
+        );
+        const {rerender} = renderHook(useExpandAttributes, {initialProps: props, wrapper});
+
+        expect(props.onStartEditing).toHaveBeenCalledWith(modifiedValues[0]);
+        jest.clearAllMocks();
+        store.profile.errors = createErrors();
+        rerender();
+        expect(props.onStartEditing).not.toHaveBeenCalled();
+        jest.clearAllMocks();
+        triggerAction(profile.actions.saveProfile());
+        store.profile.errors = createErrors();
+        rerender();
+        expect(props.onStartEditing).toHaveBeenCalledWith(modifiedValues[0]);
+    });
+});

package/src/components/ProfileTableAttributeView/components/TableAttributeEditableContent/hooks/useExpandAttributes.ts

@@ -0,0 +1,88 @@
+import {useEffect, useContext, useMemo, useRef} from 'react';
+import {pipe, prop, curry, both, map, reject, isNil, forEach, either, equals} from 'ramda';
+import {useSelector} from 'react-redux';
+import mdmModule, {profile} from '@reltio/mdm-module';
+import {
+    areOneHierarchyUris,
+    AttributeError,
+    ComplexAttributeValue,
+    ErrorType,
+    isAttributeTypeError
+} from '@reltio/mdm-sdk';
+import {useActionsHook} from '@reltio/components';
+import {TableAttributeContext} from '../../../contexts/TableAttributeContext';
+
+type Props = {
+    onStartEditing: (value: ComplexAttributeValue) => void;
+    modifiedValues: ComplexAttributeValue[];
+    highlightedError: AttributeError;
+    highlightedAttributeError: AttributeError;
+};
+
+const isMissedTypeError = (error: AttributeError) => error?.type === ErrorType.missed;
+
+const findAttributeValueByError = curry((values: ComplexAttributeValue[], error: AttributeError) =>
+    values.find(pipe(prop('uri'), either(areOneHierarchyUris(error.parentUri), equals(error.uri))))
+);
+
+export const useExpandAttributes = ({
+    onStartEditing,
+    modifiedValues,
+    highlightedError,
+    highlightedAttributeError
+}: Props) => {
+    const {attributeType} = useContext(TableAttributeContext);
+    const entityUri = useSelector(mdmModule.selectors.getEntityUri);
+    const errors = useSelector((state) =>
+        mdmModule.selectors.getActiveErrorsForAttributesPager(state, entityUri, attributeType)
+    );
+
+    const shouldOpenInvalidEditors = useRef(true);
+    const listenToActions = useActionsHook();
+
+    const missedAttributeError = useMemo(
+        () =>
+            errors.find(both(isMissedTypeError, (error) => isAttributeTypeError(error, entityUri, attributeType.uri))),
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        [errors, entityUri, attributeType.uri]
+    );
+
+    useEffect(() => {
+        if (missedAttributeError && modifiedValues.length === 1) {
+            onStartEditing(modifiedValues[0]);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [missedAttributeError]);
+
+    useEffect(() => {
+        if (shouldOpenInvalidEditors.current && errors.length) {
+            pipe(map(findAttributeValueByError(modifiedValues)), reject(isNil), forEach(onStartEditing))(errors);
+            shouldOpenInvalidEditors.current = false;
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [errors]);
+
+    useEffect(() => {
+        if (isMissedTypeError(highlightedError) && modifiedValues.length === 1) {
+            onStartEditing(modifiedValues[0]);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [highlightedError]);
+
+    useEffect(() => {
+        if (highlightedAttributeError) {
+            const attributeValue = findAttributeValueByError(modifiedValues, highlightedAttributeError);
+            if (attributeValue) onStartEditing(attributeValue);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [highlightedAttributeError]);
+
+    useEffect(() => {
+        const stopListeningActions = listenToActions((action) => {
+            if (action.type === profile.constants.ProfileActions.SAVE_PROFILE) {
+                shouldOpenInvalidEditors.current = true;
+            }
+        });
+        return () => stopListeningActions();
+    }, [listenToActions]);
+};

package/src/components/ProfileTableAttributeView/components/TableAttributeEditableContent/styles.ts

@@ -0,0 +1,21 @@
+import {makeStyles} from '@mui/styles';
+
+export const useStyles = makeStyles(() => ({
+    addButton: {
+        padding: '9px 16px 9px 12px',
+        backgroundColor: 'rgba(98, 2, 238, 0)',
+        marginBottom: '4px'
+    },
+    buttonLabel: {
+        fontSize: '14px',
+        fontWeight: 500,
+        lineHeight: '16px'
+    },
+    icon: {
+        fontSize: '18px',
+        marginRight: '8px'
+    },
+    editor: {
+        padding: '4px 16px'
+    }
+}));