@leav/ui 0.0.1-alpha-2 → 0.0.1-alpha-3

package/src/components/LibraryItemsList/hooks/useUpdateViewsOrderMutation.ts

@@ -1,54 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-import {PREFIX_SHARED_VIEWS_ORDER_KEY, PREFIX_USER_VIEWS_ORDER_KEY} from '_ui/constants';
-import {
-    GetUserDataQuery,
-    GetUserDataQueryVariables,
-    SaveUserDataMutationResult,
-    SaveUserDataMutationVariables,
-    useSaveUserDataMutation
-} from '_ui/_gqlTypes';
-import {getUserDataQuery} from '_ui/_queries/userData/getUserData';
-
-export interface IUseUpdateViewsOrderMutation {
-    updateViewsOrder: (variables: SaveUserDataMutationVariables) => Promise<SaveUserDataMutationResult>;
-}
-
-export default function useUpdateViewsOrderMutation(library: string) {
-    const [executeUpdateViewsOrder] = useSaveUserDataMutation();
-
-    return {
-        updateViewsOrder(variables: SaveUserDataMutationVariables) {
-            return executeUpdateViewsOrder({
-                variables,
-                update: (cache, mutationResult, options) => {
-                    const queryToUpdate = {
-                        query: getUserDataQuery,
-                        variables: {
-                            keys: [PREFIX_USER_VIEWS_ORDER_KEY + library, PREFIX_SHARED_VIEWS_ORDER_KEY + library]
-                        }
-                    };
-
-                    const cacheData = cache.readQuery<GetUserDataQuery, GetUserDataQueryVariables>(queryToUpdate);
-
-                    if (cacheData) {
-                        cache.writeQuery<GetUserDataQuery, GetUserDataQueryVariables>({
-                            ...queryToUpdate,
-                            data: {
-                                userData: {
-                                    global: cacheData.userData.global,
-                                    data: {
-                                        ...cacheData.userData.data,
-                                        [options.variables.key]:
-                                            mutationResult.data.saveUserData.data[options.variables.key]
-                                    }
-                                }
-                            }
-                        });
-                    }
-                }
-            });
-        }
-    };
-}

package/src/components/LibraryItemsList/index.ts

@@ -1,4 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-export {LibraryItemsList} from './LibraryItemsList';

package/src/components/LibraryItemsList/manageItems.test.ts

@@ -1,367 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-
-import {IField} from '_ui/types/search';
-import {AttributeFormat, AttributeType} from '_ui/_gqlTypes';
-import {IGetRecordsFromLibraryQueryElement} from '_ui/_queries/records/getRecordsFromLibraryQuery';
-import {mockPreviews, mockRecord} from '_ui/__mocks__/common/record';
-import {manageItems} from './manageItems';
-
-export {};
-
-describe('manageItems', () => {
-    const mockItemBase: IGetRecordsFromLibraryQueryElement = {
-        id: '123456',
-        whoAmI: {
-            ...mockRecord,
-            id: '123456',
-            label: 'record_label',
-            library: {
-                id: 'record_lib',
-                label: {fr: 'Test Lib'}
-            },
-            preview: mockPreviews,
-            color: '#123456'
-        }
-    };
-
-    const mockField: IField = {
-        id: 'myAttribute',
-        library: 'test_lib',
-        label: 'My field',
-        type: AttributeType.simple,
-        key: 'myAttribute'
-    };
-
-    test('Simple items with no fields', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [mockItemBase, mockItemBase];
-
-        const res = manageItems({items: mockItems, fields: []});
-        expect(res).toHaveLength(2);
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {}
-        });
-        expect(res[1].index).toBe(2);
-    });
-
-    test('Simple field', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myAttribute: 'myValue'
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    type: AttributeType.simple
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                myAttribute: 'myValue'
-            }
-        });
-    });
-
-    test('Field with multiple values', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myAttribute: ['myValue1', 'myValue2']
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    multipleValues: true,
-                    type: AttributeType.simple
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                myAttribute: ['myValue1', 'myValue2']
-            }
-        });
-    });
-
-    test('Simple field via link attribute', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myLinkAttribute: {
-                    myAttribute: 'myValue'
-                }
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    type: AttributeType.simple,
-                    parentAttributeData: {
-                        id: 'myLinkAttribute',
-                        type: AttributeType.simple_link
-                    }
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                myAttribute: 'myValue'
-            }
-        });
-    });
-
-    test('Simple field via tree attribute', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myTreeAttribute: {
-                    record: {
-                        myAttribute: 'myValue'
-                    }
-                }
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    key: 'myTreeAttribute.test_lib.myAttribute',
-                    type: AttributeType.simple,
-                    parentAttributeData: {
-                        id: 'myTreeAttribute',
-                        type: AttributeType.tree
-                    }
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                'myTreeAttribute.test_lib.myAttribute': 'myValue'
-            }
-        });
-    });
-
-    test('Advanced field with multiple values via link attribute', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myLinkAttribute: {
-                    myAttribute: ['myValue1', 'myValue2']
-                }
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    type: AttributeType.simple,
-                    parentAttributeData: {
-                        id: 'myLinkAttribute',
-                        type: AttributeType.simple_link
-                    }
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                myAttribute: ['myValue1', 'myValue2']
-            }
-        });
-    });
-
-    test('Simple field via link attribute with multiple values', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myLinkAttribute: [
-                    {
-                        myAttribute: 'myValue1'
-                    },
-                    {
-                        myAttribute: 'myValue2'
-                    }
-                ]
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    type: AttributeType.simple,
-                    parentAttributeData: {
-                        id: 'myLinkAttribute',
-                        type: AttributeType.simple_link
-                    }
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                myAttribute: ['myValue1', 'myValue2']
-            }
-        });
-    });
-
-    test('Link attribute with no subfields', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myLinkAttribute: {
-                    id: '1',
-                    whoAmI: {...mockItemBase.whoAmI}
-                }
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    id: 'myLinkAttribute',
-                    key: 'myLinkAttribute',
-                    type: AttributeType.simple_link
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                myLinkAttribute: {id: '1', whoAmI: {...mockItemBase.whoAmI}}
-            }
-        });
-    });
-
-    test('Tree attribute with no subfields', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myTreeAttribute: {
-                    id: '1',
-                    whoAmI: {...mockItemBase.whoAmI}
-                }
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    id: 'myTreeAttribute',
-                    key: 'myTreeAttribute',
-                    type: AttributeType.tree
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                myTreeAttribute: {id: '1', whoAmI: {...mockItemBase.whoAmI}}
-            }
-        });
-    });
-
-    test('Extended attribute field', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myAttribute: '{"foo":"bar"}'
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    type: AttributeType.simple,
-                    format: AttributeFormat.extended
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                myAttribute: '{"foo":"bar"}'
-            }
-        });
-    });
-
-    test('Extended attribute field, nested field', async () => {
-        const mockItems: IGetRecordsFromLibraryQueryElement[] = [
-            {
-                ...mockItemBase,
-                myAttribute: '{"foo":"bar"}'
-            }
-        ];
-
-        const res = manageItems({
-            items: mockItems,
-            fields: [
-                {
-                    ...mockField,
-                    key: 'myAttribute.foo',
-                    type: AttributeType.simple,
-                    format: AttributeFormat.extended
-                }
-            ]
-        });
-
-        expect(res[0]).toEqual({
-            whoAmI: {...mockItemBase.whoAmI},
-            index: 1,
-            fields: {
-                'myAttribute.foo': 'bar'
-            }
-        });
-    });
-});

package/src/components/LibraryItemsList/manageItems.ts

@@ -1,124 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-import isArray from 'lodash/isArray';
-import objectPath from 'object-path';
-import {IField, IItem} from '_ui/types/search';
-import {AttributeFormat, AttributeType} from '_ui/_gqlTypes';
-import {IGetRecordsFromLibraryQueryElement} from '_ui/_queries/records/getRecordsFromLibraryQuery';
-
-const _extractValueFromParent = (field: IField, linkValue: any) => {
-    const linkedElement = field.parentAttributeData.type === AttributeType.tree ? linkValue.record : linkValue;
-    return linkedElement[field.id];
-};
-
-const manageFields = (fields: IField[], item: IGetRecordsFromLibraryQueryElement) => {
-    return fields.reduce((acc, field) => {
-        const key: string = field.key;
-
-        if (field.format === AttributeFormat.extended) {
-            const [attributeId, ...path] = key.split('.');
-
-            try {
-                // If we ask for the whole extended attribute, just return the json
-                if (!path.length) {
-                    acc[key] = item[attributeId];
-                    return acc;
-                }
-
-                // If we ask for a specific field, parse json and return value
-                const attributeExtendedContent = JSON.parse(item[attributeId]);
-                if (attributeExtendedContent) {
-                    acc[key] = objectPath.get(attributeExtendedContent, path);
-                    return acc;
-                }
-            } catch (e) {
-                console.error(e);
-
-                acc[key] = 'error';
-                return acc;
-            }
-        }
-
-        switch (field.type) {
-            case AttributeType.simple_link:
-            case AttributeType.advanced_link:
-                if (field?.parentAttributeData && item[field.parentAttributeData.id]) {
-                    let value = item[field.parentAttributeData.id][field.id];
-
-                    if (isArray(item[field.parentAttributeData.id])) {
-                        value = item[field.parentAttributeData.id].map(tree => tree.record[field.id]);
-                    }
-
-                    if (Array.isArray(value)) {
-                        value = value.shift();
-                    }
-
-                    acc[key] = value;
-                } else {
-                    acc[key] = item[field.id];
-                }
-                return acc;
-            case AttributeType.tree:
-                if (field?.parentAttributeData && item[field.parentAttributeData.id]) {
-                    acc[key] = item[field.parentAttributeData.id][field.id];
-                } else {
-                    acc[key] = item[field.id];
-                }
-
-                return acc;
-            case AttributeType.simple:
-            case AttributeType.advanced:
-            default:
-                // Simple field, not via link or tree attribute
-                if (!field?.parentAttributeData) {
-                    acc[key] = item[field.id];
-                    return acc;
-                }
-
-                // Attribute via link or tree, but no value
-                if (!item[field.parentAttributeData.id]) {
-                    acc[key] = null;
-                    return acc;
-                }
-
-                // Parent attribute has multiple values, value is an array
-                if (isArray(item[field.parentAttributeData.id])) {
-                    acc[key] = item[field.parentAttributeData.id].map(linkValue => {
-                        return _extractValueFromParent(field, linkValue);
-                    });
-                    return acc;
-                }
-
-                // Parent attribute has not multiple values, value is not an array
-                const linkValue = item[field.parentAttributeData.id];
-                acc[key] = _extractValueFromParent(field, linkValue);
-
-                return acc;
-        }
-    }, {});
-};
-
-interface IManageItemsProps {
-    items: IGetRecordsFromLibraryQueryElement[];
-    fields: IField[];
-}
-
-/**
- * Convert search result to a list of items usable by LibraryItemsList
- */
-export const manageItems = ({items, fields}: IManageItemsProps): IItem[] => {
-    const resultItems: IItem[] = items.map((item, index) => {
-        const itemFields = manageFields(fields, item);
-
-        const resultItem: IItem = {
-            index: index + 1,
-            whoAmI: {...item.whoAmI},
-            fields: itemFields
-        };
-
-        return resultItem;
-    });
-
-    return resultItems;
-};

package/src/components/LibraryItemsList/shared/DeactivateRecordBtn/DeactivateRecordBtn.test.tsx

@@ -1,49 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-import userEvent from '@testing-library/user-event';
-import {SearchContext} from '_ui/components/LibraryItemsList/hooks/useSearchReducer/searchContext';
-import {initialSearchState} from '_ui/components/LibraryItemsList/hooks/useSearchReducer/searchReducer';
-import {DeactivateRecordsDocument} from '_ui/_gqlTypes';
-import {render, screen, waitFor} from '_ui/_tests/testUtils';
-import {mockRecord} from '_ui/__mocks__/common/record';
-import DeactivateRecordBtn from './DeactivateRecordBtn';
-
-describe('DeactivateRecordBtn', () => {
-    test('Render test', async () => {
-        let mutationCalled = false;
-        const mocks = [
-            {
-                request: {
-                    query: DeactivateRecordsDocument,
-                    variables: {
-                        libraryId: mockRecord.library.id,
-                        recordsIds: [mockRecord.id]
-                    }
-                },
-                result: () => {
-                    mutationCalled = true;
-                    return {
-                        data: {
-                            deactivateRecords: [{id: '1'}, {id: '2'}]
-                        }
-                    };
-                }
-            }
-        ];
-
-        render(
-            <SearchContext.Provider value={{state: initialSearchState, dispatch: jest.fn()}}>
-                <DeactivateRecordBtn record={mockRecord} />
-            </SearchContext.Provider>,
-            {mocks}
-        );
-
-        userEvent.click(screen.getByRole('button', {name: /delete/i}));
-        expect(await screen.findByText(/confirm_one/i)).toBeInTheDocument();
-
-        userEvent.click(screen.getByText(/submit/i));
-
-        await waitFor(() => expect(mutationCalled).toBe(true));
-    });
-});

package/src/components/LibraryItemsList/shared/DeactivateRecordBtn/DeactivateRecordBtn.tsx

@@ -1,53 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-import {DeleteOutlined} from '@ant-design/icons';
-import {Button, ButtonProps} from 'antd';
-import confirm from 'antd/lib/modal/confirm';
-import {SyntheticEvent} from 'react';
-import useSearchReducer from '_ui/components/LibraryItemsList/hooks/useSearchReducer/';
-import {SearchActionTypes} from '_ui/components/LibraryItemsList/hooks/useSearchReducer/searchReducer';
-import {useSharedTranslation} from '_ui/hooks/useSharedTranslation';
-import {IRecordIdentityWhoAmI} from '_ui/types/records';
-import {useDeactivateRecordsMutation} from '_ui/_gqlTypes';
-import {stopEvent} from '_ui/_utils';
-
-interface IDeactivateRecordBtnProps extends ButtonProps {
-    record: IRecordIdentityWhoAmI;
-}
-
-function DeactivateRecordBtn({record, ...buttonProps}: IDeactivateRecordBtnProps): JSX.Element {
-    const {t} = useSharedTranslation();
-
-    const {dispatch: searchDispatch} = useSearchReducer();
-
-    const [deactivateRecords] = useDeactivateRecordsMutation({
-        variables: {
-            libraryId: record.library.id,
-            recordsIds: [record.id]
-        }
-    });
-
-    const _handleClickConfirm = async () => {
-        await deactivateRecords();
-
-        searchDispatch({type: SearchActionTypes.SET_LOADING, loading: true}); // Refresh the search
-    };
-
-    const _handleClick = async (e: SyntheticEvent) => {
-        stopEvent(e);
-
-        confirm({
-            content: t('records_deactivation.confirm_one'),
-            okText: t('global.submit'),
-            cancelText: t('global.cancel'),
-            onOk: _handleClickConfirm
-        });
-    };
-
-    return (
-        <Button name="deactivate" icon={<DeleteOutlined />} shape="circle" {...buttonProps} onClick={_handleClick} />
-    );
-}
-
-export default DeactivateRecordBtn;

package/src/components/LibraryItemsList/shared/DeactivateRecordBtn/index.ts

@@ -1,5 +0,0 @@
-// Copyright LEAV Solutions 2017
-// This file is released under LGPL V3
-// License text available at https://www.gnu.org/licenses/lgpl-3.0.txt
-import DeactivateRecordBtn from './DeactivateRecordBtn';
-export default DeactivateRecordBtn;