@reltio/profile 1.4.1585 → 1.4.1586-mui5

package/src/components/ProfileRelationsView/helpers/__tests__/ratings.test.ts

@@ -0,0 +1,92 @@
+import {Rating} from '@reltio/mdm-sdk';
+import {calcAverageRating, getCountOfLikes, getCountOfDislikes, calcRatingsScale, sortRatingsByTime} from '../ratings';
+
+describe('ratings tests', () => {
+    it('sortRatingsByTime should work correctly', () => {
+        const input = [
+            {user: 'test1', value: 1, comment: 'Other', timestamp: '2023-05-01T09:57:18.066+0000'},
+            {user: 'test2', value: 1, comment: 'Comment', timestamp: '2023-05-02T09:57:18.066+0000'},
+            {user: 'test3', value: 5, comment: '', timestamp: '2023-05-03T09:57:18.066+0000'},
+            {user: 'test4', value: 5, comment: '', timestamp: '2023-05-01T09:56:18.066+0000'}
+        ] as Rating[];
+        const output = [
+            {user: 'test3', value: 5, comment: '', timestamp: '2023-05-03T09:57:18.066+0000'},
+            {user: 'test2', value: 1, comment: 'Comment', timestamp: '2023-05-02T09:57:18.066+0000'},
+            {user: 'test1', value: 1, comment: 'Other', timestamp: '2023-05-01T09:57:18.066+0000'},
+            {user: 'test4', value: 5, comment: '', timestamp: '2023-05-01T09:56:18.066+0000'}
+        ];
+        expect(sortRatingsByTime(input)).toEqual(output);
+    });
+    it('calcAverageRating should work correctly', () => {
+        expect(calcAverageRating([])).toBe('0.0');
+        expect(calcAverageRating([{value: 1}, {value: 5}] as Rating[])).toBe('3.0');
+        expect(calcAverageRating([{value: 5}, {value: 5}] as Rating[])).toBe('5.0');
+        expect(calcAverageRating([{value: 1}, {value: 1}] as Rating[])).toBe('1.0');
+        expect(calcAverageRating([{value: 1}, {value: 1}, {value: 5}] as Rating[])).toBe('2.3');
+        expect(calcAverageRating([{value: 1}, {value: 5}, {value: 5}] as Rating[])).toBe('3.7');
+        expect(calcAverageRating([{value: 1}, {value: 5}, {value: 5}, {value: 5}] as Rating[])).toBe('4.0');
+    });
+
+    it('calcAverageRating should work correctly', () => {
+        expect(calcAverageRating([])).toBe('0.0');
+        expect(calcAverageRating([{value: 1}, {value: 5}] as Rating[])).toBe('3.0');
+        expect(calcAverageRating([{value: 5}, {value: 5}] as Rating[])).toBe('5.0');
+        expect(calcAverageRating([{value: 1}, {value: 1}] as Rating[])).toBe('1.0');
+        expect(calcAverageRating([{value: 1}, {value: 1}, {value: 5}] as Rating[])).toBe('2.3');
+        expect(calcAverageRating([{value: 1}, {value: 5}, {value: 5}] as Rating[])).toBe('3.7');
+        expect(calcAverageRating([{value: 1}, {value: 5}, {value: 5}, {value: 5}] as Rating[])).toBe('4.0');
+    });
+
+    it('getCountOfLikes should work correctly', () => {
+        expect(getCountOfLikes([{value: 5}, {value: 1}, {value: 5}] as Rating[])).toBe(2);
+        expect(getCountOfLikes([{value: 5}, {value: 1}, {value: 5}, {value: 5}] as Rating[])).toBe(3);
+        expect(getCountOfLikes([{value: 1}, {value: 1}, {value: 1}] as Rating[])).toBe(0);
+        expect(getCountOfLikes([{value: 5}] as Rating[])).toBe(1);
+        expect(getCountOfLikes([] as Rating[])).toBe(0);
+    });
+
+    it('getCountOfDislikes should work correctly', () => {
+        expect(getCountOfDislikes([{value: 5}, {value: 1}, {value: 5}] as Rating[])).toBe(1);
+        expect(getCountOfDislikes([{value: 5}, {value: 1}, {value: 1}, {value: 5}] as Rating[])).toBe(2);
+        expect(getCountOfDislikes([{value: 1}, {value: 1}, {value: 1}] as Rating[])).toBe(3);
+        expect(getCountOfDislikes([{value: 1}] as Rating[])).toBe(1);
+        expect(getCountOfDislikes([] as Rating[])).toBe(0);
+    });
+
+    it.each([
+        {
+            input: [{value: 5}],
+            output: {percentOfLikes: 100, percentOfDislikes: 0}
+        },
+        {
+            input: [{value: 1}],
+            output: {percentOfLikes: 0, percentOfDislikes: 100}
+        },
+        {
+            input: [{value: 5}, {value: 1}],
+            output: {percentOfLikes: 50, percentOfDislikes: 50}
+        },
+        {
+            input: [{value: 5}, {value: 5}, {value: 5}, {value: 1}],
+            output: {percentOfLikes: 75, percentOfDislikes: 25}
+        },
+        {
+            input: [{value: 1}, {value: 1}, {value: 1}, {value: 5}],
+            output: {percentOfLikes: 25, percentOfDislikes: 75}
+        },
+        {
+            input: [{value: 1}, {value: 1}, {value: 5}],
+            output: {percentOfLikes: 33.3, percentOfDislikes: 66.7}
+        },
+        {
+            input: [{value: 5}, {value: 5}, {value: 1}],
+            output: {percentOfLikes: 66.7, percentOfDislikes: 33.3}
+        },
+        {
+            input: [],
+            output: {percentOfLikes: 0, percentOfDislikes: 0}
+        }
+    ])('calcRatingsScale should work correctly', ({input, output}) => {
+        expect(calcRatingsScale(input as Rating[])).toEqual(output);
+    });
+});

package/src/components/ProfileRelationsView/helpers/__tests__/relation.test.tsx

@@ -0,0 +1,27 @@
+import {Directions} from '@reltio/mdm-sdk';
+import {getFirstRelationTypeObject} from '../relation';
+
+describe('relation helpers tests', () => {
+    describe('getFirstRelationTypeObject behavior', () => {
+        it('should return correct relation type object', () => {
+            const inRelation = ['relationType1', 'relationType2'];
+            const outRelation = ['relationType3'];
+            expect(getFirstRelationTypeObject(inRelation, outRelation)).toEqual({
+                type: 'relationType1',
+                direction: Directions.IN
+            });
+        });
+
+        it('should return correct relation type object even if in/out relations are objects', () => {
+            const inRelation = [
+                {uri: 'relationType1', label: '{directionalLabel}'},
+                {uri: 'relationType2', label: '{directionalLabel}'}
+            ];
+            const outRelation = [{uri: 'relationType3', label: '{directionalLabel}'}];
+            expect(getFirstRelationTypeObject(inRelation, outRelation)).toEqual({
+                type: 'relationType1',
+                direction: Directions.IN
+            });
+        });
+    });
+});

package/src/components/ProfileRelationsView/helpers/filters.ts

@@ -0,0 +1,17 @@
+import {FilterBuilder, Maybe, filterValueToQueryStringWithQuotes} from '@reltio/mdm-sdk';
+
+const buildRelationsFilter = (searchQuery) => {
+    const queryClause = Maybe.fromFalsy<string>(searchQuery)
+        .map(filterValueToQueryStringWithQuotes)
+        .map(
+            (queryString) =>
+                `containsWordStartingWith(entity.label,${queryString})` +
+                ' or ' +
+                `containsWordStartingWith(relation.label,${queryString})`
+        )
+        .orSome('');
+
+    return new FilterBuilder().addClause(queryClause).build();
+};
+
+export {buildRelationsFilter};

package/src/components/ProfileRelationsView/helpers/permissions.ts

@@ -0,0 +1,17 @@
+import {checkMetadataForDelete, checkMetadataForUpdate, checkRemoved, getRelationType, Mode} from '@reltio/mdm-sdk';
+
+export const checkRelationPermission = ({metadata, mode, connection, onRemoveRelation, onEditRelation}) => {
+    const isEditableMode = mode === Mode.Editing || mode === Mode.Suggesting;
+    if (isEditableMode && connection) {
+        const {
+            relation: {relationType}
+        } = connection;
+        const isRemoved = checkRemoved(connection);
+        const relationTypeMetadata = getRelationType(metadata, relationType);
+        const canRemove = onRemoveRelation && !isRemoved && checkMetadataForDelete(mode, relationTypeMetadata);
+        const canUpdate = onEditRelation && !isRemoved && checkMetadataForUpdate(mode, relationTypeMetadata);
+        return {canRemove, canUpdate};
+    } else {
+        return {canRemove: false, canUpdate: false};
+    }
+};

package/src/components/ProfileRelationsView/helpers/ratings.ts

@@ -0,0 +1,35 @@
+import {pluck, mean, pipe, defaultTo} from 'ramda';
+import {Rating} from '@reltio/mdm-sdk';
+
+export const sortRatingsByTime = (ratings: Rating[]) => {
+    return [...ratings].sort((a, b) => {
+        const timestampA = new Date(a.timestamp).getTime();
+        const timestampB = new Date(b.timestamp).getTime();
+        return timestampB - timestampA;
+    });
+};
+
+export const calcAverageRating = (ratings: Rating[]) => {
+    const averageRating: number = pipe(pluck('value'), mean, defaultTo(0))(ratings);
+    return averageRating.toFixed(1);
+};
+
+export const getCountOfLikes = (ratings: Rating[]) => {
+    return ratings.filter((rating) => rating.value === 5).length;
+};
+
+export const getCountOfDislikes = (ratings: Rating[]) => {
+    return ratings.filter((rating) => rating.value === 1).length;
+};
+
+export const calcRatingsScale = (ratings: Rating[]) => {
+    if (ratings.length === 0) {
+        return {percentOfLikes: 0, percentOfDislikes: 0};
+    }
+
+    const percentOfLikes = (getCountOfLikes(ratings) / ratings.length) * 100;
+    const formattedPercentOfLikes = parseFloat(Number(percentOfLikes).toFixed(1));
+    const formattedPercentOfDislikes = parseFloat(Number(100 - formattedPercentOfLikes).toFixed(1));
+
+    return {percentOfLikes: formattedPercentOfLikes, percentOfDislikes: formattedPercentOfDislikes};
+};

package/src/components/ProfileRelationsView/helpers/relation.ts

@@ -0,0 +1,15 @@
+import {prop, when} from 'ramda';
+import {Directions, wrapInArrayIfNeeded, InOutRelation, isObject, ComplexInOutRelationItem} from '@reltio/mdm-sdk';
+
+const getUri: (relation: string | ComplexInOutRelationItem) => string = when(isObject, prop('uri'));
+
+export const getFirstRelationTypeObject = (inRelations: InOutRelation, outRelations: InOutRelation) => {
+    const prepareRelation = (direction: string, relations: InOutRelation) => {
+        const relationsArr = relations ? wrapInArrayIfNeeded(relations) : [];
+        return relationsArr.map((relation) => ({
+            type: getUri(relation),
+            direction: direction === Directions.IN ? Directions.IN : Directions.OUT
+        }));
+    };
+    return prepareRelation(Directions.IN, inRelations).concat(prepareRelation(Directions.OUT, outRelations))[0];
+};

package/src/components/ProfileRelationsView/hooks/useRelationInfo.ts

@@ -0,0 +1,25 @@
+import {
+    Connection,
+    Metadata,
+    getEntityType,
+    getLabel,
+    getEntityUriForLink,
+    getRelationTypeLabelFromMetadata,
+    TEntityType
+} from '@reltio/mdm-sdk';
+
+export const useRelationInfo = (connection: Connection, metadata: Metadata) => {
+    const {entity, relation} = connection;
+    const entityType = getEntityType(metadata, entity?.entityType) as TEntityType;
+    const entityLabel = getLabel(entity?.entityLabel) as string;
+    const preparedUri = getEntityUriForLink({uri: entity?.entityUri, dataTenant: entity?.dataTenant}) as string;
+    const relationLabel =
+        relation?.relationLabel || (getRelationTypeLabelFromMetadata(metadata, relation?.relationType) as string);
+
+    return {
+        entityType,
+        entityLabel,
+        preparedUri,
+        relationLabel
+    };
+};

package/src/components/ProfileRelationsView/hooks/useRelationsState.ts

@@ -0,0 +1,92 @@
+import {useCallback, useMemo, useState} from 'react';
+import {pipe, map, unless, append, propEq} from 'ramda';
+import i18n from 'ui-i18n';
+import {RelationsViewConfig, SortOrder, isEmptyValue} from '@reltio/mdm-sdk';
+
+const DEFAULT_ROWS_PER_PAGE = 15;
+const DEFAULT_SORT_ORDER = 'asc';
+const DEFAULT_SHOW_INACTIVE = false;
+
+type Option = {
+    value: string;
+    label: string;
+};
+
+export type RelationsViewState = {
+    searchQuery: string;
+    changeSearchQuery: (value: string) => void;
+    sortOrder: SortOrder;
+    toggleSortOrder: () => void;
+    sortOption?: string;
+    changeSortOption: (option: string) => void;
+    sortOptions: Option[];
+    page: number;
+    setPage: (page: number) => void;
+    rowsPerPage: number;
+    showInactive: boolean;
+    toggleShowInactive: () => void;
+};
+
+const useRelationsState = (config: RelationsViewConfig): RelationsViewState => {
+    const sortOptions = useMemo(
+        () =>
+            pipe(
+                Object.entries,
+                map(([key, value]) => ({
+                    value: key,
+                    label: value
+                })),
+                unless(
+                    (options) => isEmptyValue(options) || options.some(propEq('value', 'name')),
+                    append({label: i18n.text('Name'), value: 'name'})
+                )
+            )(config.sortOptions || {}),
+        [config.sortOptions]
+    );
+
+    const rowsPerPage = Number(config.max) || DEFAULT_ROWS_PER_PAGE;
+    const [page, setPage] = useState(0);
+    const [sortOrder, setSortOrder] = useState(config.sortOrder || DEFAULT_SORT_ORDER);
+    const [sortOption, setSortOption] = useState(sortOptions[0]?.value);
+    const [searchQuery, setSearchQuery] = useState('');
+    const [showInactive, setShowInactive] = useState(DEFAULT_SHOW_INACTIVE);
+
+    const toggleShowInactive = useCallback(() => {
+        setPage(0);
+        setShowInactive((showInactive) => !showInactive);
+    }, []);
+
+    const toggleSortOrder = useCallback(() => {
+        setPage(0);
+        setSortOrder((order) => {
+            return order === 'asc' ? 'desc' : 'asc';
+        });
+    }, []);
+
+    const changeSortOption = useCallback((option: string) => {
+        setPage(0);
+        setSortOption(option);
+    }, []);
+
+    const changeSearchQuery = useCallback((value: string) => {
+        setPage(0);
+        setSearchQuery(value);
+    }, []);
+
+    return {
+        searchQuery,
+        changeSearchQuery,
+        sortOrder,
+        toggleSortOrder,
+        sortOption,
+        changeSortOption,
+        sortOptions,
+        page,
+        setPage,
+        rowsPerPage,
+        showInactive,
+        toggleShowInactive
+    };
+};
+
+export default useRelationsState;

package/src/components/ProfileRelationsView/hooks/useSecondLevelConnections.ts

@@ -0,0 +1,76 @@
+import {useState, useCallback} from 'react';
+import {useSelector, useDispatch} from 'react-redux';
+import {
+    Connection,
+    getRelationsForEntity,
+    ActivityFilter,
+    GlobalSearchRequestOptions,
+    RelationsViewConfig
+} from '@reltio/mdm-sdk';
+import mdmModule, {profile} from '@reltio/mdm-module';
+
+type Params = {
+    config: RelationsViewConfig;
+    connection: Connection;
+    relationActivityFilter: ActivityFilter;
+};
+
+export const useSecondLevelConnections = ({config, connection, relationActivityFilter}: Params) => {
+    const dispatch = useDispatch();
+
+    const [showSecondLevel, setShowSecondLevel] = useState(false);
+    const [loading, setLoading] = useState(false);
+
+    const {contentSecondLevel} = config;
+    const {entity} = connection;
+
+    const connections =
+        (useSelector((state) =>
+            mdmModule.selectors.getConnectionsWithDraftsByViewId(state, config.id, entity.entityUri)
+        ) as Connection[]) || [];
+
+    const total = useSelector((state) => mdmModule.selectors.getTotalByViewId(state, config.id, entity.entityUri));
+    const {activityFilter}: GlobalSearchRequestOptions =
+        useSelector(mdmModule.selectors.getGlobalSearchRequestOptions) || {};
+
+    const loadRelations = useCallback(() => {
+        const requestConfig = {
+            ...contentSecondLevel,
+            returnObjects: true,
+            returnDates: true,
+            activeness: {
+                relation: relationActivityFilter || ActivityFilter.ALL,
+                entity: activityFilter
+            }
+        };
+
+        setLoading(true);
+
+        getRelationsForEntity(entity.entityUri, [requestConfig]).then((response) => {
+            const {connections, total} = response[0];
+
+            if (connections) {
+                dispatch(
+                    profile.relations.actions.secondLevelRelationsLoaded({
+                        connections,
+                        parentEntityUri: entity.entityUri,
+                        id: config.id,
+                        total
+                    })
+                );
+            }
+
+            setLoading(false);
+        });
+    }, [config.id, contentSecondLevel, dispatch, entity.entityUri, activityFilter, relationActivityFilter]);
+
+    const toggleShowSecondLevel = useCallback(() => {
+        if (!showSecondLevel && !connection.connections) {
+            loadRelations();
+        }
+
+        setShowSecondLevel((show) => !show);
+    }, [loadRelations, connection.connections, showSecondLevel]);
+
+    return {connections, showSecondLevel, toggleShowSecondLevel, loadRelations, loading, total};
+};

package/src/components/ProfileRelationsView/hooks/useSuggestedRelations.ts

@@ -0,0 +1,54 @@
+import {useDispatch} from 'react-redux';
+import i18n from 'ui-i18n';
+import {
+    Connection,
+    ignoreSuggestedRelation,
+    createRelation,
+    getRequestErrorMessage,
+    Directions,
+    RelationsContent
+} from '@reltio/mdm-sdk';
+import {ui} from '@reltio/mdm-module';
+import {getFirstRelationTypeObject} from '../helpers/relation';
+
+export const useSuggestedRelations = (content: RelationsContent, loadRelations: () => void, mainEnityUri: string) => {
+    const relationTypeObject = getFirstRelationTypeObject(content.inRelations, content.outRelations);
+    const dispatch = useDispatch();
+    const ignoreRelation = (connection: Connection) => () => {
+        const {entity} = connection;
+        ignoreSuggestedRelation(mainEnityUri, {
+            relatedEntityUri: entity.entityUri,
+            relationType: relationTypeObject.type,
+            relationDirection: relationTypeObject.direction
+        })
+            .then(loadRelations)
+            .catch((error) => {
+                dispatch(ui.actions.errorSet(getRequestErrorMessage(error, i18n.text('Something went wrong'))));
+            });
+    };
+
+    const acceptRelation = (connection: Connection) => () => {
+        const {entity, relation} = connection;
+        const {startDate, endDate} = relation;
+        const isInDirection = relationTypeObject.direction === Directions.IN;
+        const startEntityUri = isInDirection ? entity.entityUri : mainEnityUri;
+        const endEntityUri = isInDirection ? mainEnityUri : entity.entityUri;
+        createRelation({
+            startEntityUri,
+            endEntityUri,
+            relationType: relationTypeObject.type,
+            attributes: null,
+            startDate,
+            endDate
+        })
+            .then(loadRelations)
+            .catch((error) => {
+                dispatch(ui.actions.errorSet(getRequestErrorMessage(error, i18n.text('Something went wrong'))));
+            });
+    };
+
+    return {
+        ignoreRelation,
+        acceptRelation
+    };
+};

package/src/components/ProfileSingleAttributeView/ProfileSingleAttributeView.tsx

@@ -0,0 +1,20 @@
+import React from 'react';
+import {SingleAttributeViewConfig} from '@reltio/mdm-sdk';
+import {SingleAttributeContext} from './contexts/SingleAttributeContext';
+import {SingleAttributeView} from './components/SingleAttributeView/SingleAttributeView';
+import {useSingleAttribute} from './hooks/useSingleAttribute';
+
+type Props = {
+    config: SingleAttributeViewConfig;
+    className?: string;
+};
+
+export const ProfileSingleAttributeView = ({className, config}: Props) => {
+    const singleAttribute = useSingleAttribute(config);
+
+    return (
+        <SingleAttributeContext.Provider value={singleAttribute}>
+            <SingleAttributeView config={config} className={className} />
+        </SingleAttributeContext.Provider>
+    );
+};