@reltio/dashboard 1.4.1585 → 1.4.1586-mui5

package/src/services/facets.ts

@@ -0,0 +1,178 @@
+import {
+    AttributeType,
+    attributeUriToSearchUri,
+    buildLookupRecord,
+    DashboardConfigFilter,
+    formatDataTypeValue,
+    getAttrDataTypeDefinition,
+    getAttrTypeLookupCode,
+    getEntityUriFromAttributeUri,
+    getFacets,
+    getRoleLabel,
+    getTotals,
+    isDateType,
+    isEntityTypeUri,
+    isLookupAttrType,
+    isRoleAttrType,
+    Metadata,
+    parseTimestamp,
+    resolveLookupsList
+} from '@reltio/mdm-sdk';
+import {
+    always,
+    ascend,
+    concat,
+    curry,
+    defaultTo,
+    descend,
+    evolve,
+    ifElse,
+    map,
+    pipe,
+    prop,
+    propEq,
+    reject,
+    sortWith,
+    when
+} from 'ramda';
+import {
+    buildQuery,
+    configFilterToSearchFilter,
+    convertFilterToFacetState,
+    createEntityTypeFilter,
+    createFacetItemFilter,
+    createNotEqualFilter,
+    isEntityTypeFilter,
+    isSomeEntityTypeFilter
+} from './filters';
+import {ChartData} from '@reltio/components';
+import i18n from 'ui-i18n';
+
+type FacetsRequest = {
+    attribute: string;
+    filters: DashboardConfigFilter[];
+    globalFilter?: string;
+    searchByOv?: boolean;
+    activityFilter?: string;
+    pageSize?: number;
+    orderType?: string;
+};
+
+export const requestFacets = ({
+    attribute,
+    filters,
+    globalFilter,
+    searchByOv,
+    activityFilter,
+    pageSize,
+    orderType
+}: FacetsRequest): Promise<ChartData[]> => {
+    const query = buildQuery(filters, globalFilter, searchByOv, activityFilter);
+    const body = [
+        {
+            fieldName: attribute,
+            pageNo: 1,
+            orderType,
+            pageSize
+        }
+    ];
+    return getFacets({query, body}).then((response) => {
+        const getFacetData = pipe(
+            prop(attribute),
+            defaultTo({}),
+            Object.entries,
+            map(([key, value]) => ({label: key, group: key, value})),
+            sortWith([descend(prop('value')), ascend(prop('label'))])
+        );
+        return getFacetData(response);
+    });
+};
+
+export const resolveLookups = curry((lookupCode: string, data: ChartData[]) => {
+    const lookupsToResolve = data.map(({label}) => ({codeValue: label, type: lookupCode}));
+    return resolveLookupsList(lookupsToResolve).then((response) => {
+        const codes = response.flatMap(buildLookupRecord(lookupCode)) as {lookupCode: string; value: string}[];
+        return data.map((item) => {
+            const code = codes.find(({lookupCode}) => lookupCode === item.label);
+            return code ? {...item, label: code.value} : item;
+        });
+    });
+});
+
+const buildFacetOthersFilters = curry((fieldName: string, data: ChartData[]) =>
+    data.map(pipe(prop('group'), createNotEqualFilter(fieldName)))
+);
+
+const OTHER_FACET_GROUP = 'Other';
+
+export const requestOtherValues = curry(
+    ({attribute, filters, globalFilter, searchByOv, activityFilter}: FacetsRequest, data: ChartData[]) => {
+        const otherFilters = pipe(
+            buildFacetOthersFilters(attribute),
+            concat(filters),
+            map(configFilterToSearchFilter)
+        )(data);
+        const searchOptions = searchByOv && 'searchByOv';
+        return getTotals(otherFilters, {globalFilter, activityFilter, searchOptions}).then(({total}) => {
+            return total > 0
+                ? data.concat([{label: i18n.text('Other'), group: OTHER_FACET_GROUP, value: total}])
+                : data;
+        });
+    }
+);
+
+const resolveRoleLabel = (metadata: Metadata, roleName: string) =>
+    getRoleLabel(metadata, 'configuration/roles/' + roleName);
+
+export const localizeFacetValues = map((facet: ChartData) => ({
+    ...facet,
+    localizedValue: i18n.number(facet.value)
+}));
+
+export const resolveFacetLabels = (metadata: Metadata, attrType: AttributeType) =>
+    pipe(
+        when(() => isLookupAttrType(attrType), resolveLookups(getAttrTypeLookupCode(attrType))),
+        when(
+            () => isRoleAttrType(attrType),
+            map((facet) => ({...facet, label: resolveRoleLabel(metadata, facet.group)}))
+        ),
+        when(
+            () => isDateType(attrType.type),
+            map(
+                evolve({
+                    label: pipe(
+                        parseTimestamp,
+                        formatDataTypeValue({dataTypeDefinition: getAttrDataTypeDefinition(attrType)})
+                    )
+                })
+            )
+        )
+    );
+
+export const getFacetFieldName = when(isEntityTypeUri, attributeUriToSearchUri);
+const getFacetEntityTypeUri = ifElse(isEntityTypeUri, getEntityUriFromAttributeUri, always(undefined));
+
+export const getFiltersForFacet = (
+    attributeUri: string,
+    filters: DashboardConfigFilter[] = []
+): DashboardConfigFilter[] => {
+    const entityTypeUri = getFacetEntityTypeUri(attributeUri);
+    const hasEntityTypeFilter = filters.some((filter) => isEntityTypeFilter(filter, entityTypeUri));
+    return entityTypeUri && !hasEntityTypeFilter ? [createEntityTypeFilter(entityTypeUri), ...filters] : filters;
+};
+
+export const getFiltersForFacetItem = curry((attributeUri: string, data: ChartData[], group: string) => {
+    const fieldName = getFacetFieldName(attributeUri);
+    return group === OTHER_FACET_GROUP
+        ? pipe(reject(propEq('group', OTHER_FACET_GROUP)), buildFacetOthersFilters(fieldName))(data)
+        : [createFacetItemFilter(fieldName, group)];
+});
+
+export const facetFiltersToSearchState = curry(
+    (metadata: Metadata, attributeUri: string, filters: DashboardConfigFilter[]) => {
+        const entityType = getFacetEntityTypeUri(attributeUri) || filters.find(isSomeEntityTypeFilter)?.values?.[0];
+        return {
+            facets: filters.map(convertFilterToFacetState(metadata, entityType))
+        };
+    }
+);

package/src/services/filters.ts

@@ -0,0 +1,87 @@
+import {
+    addGlobalFilterToQuery,
+    buildFilterQueryString,
+    DashboardConfigFilter,
+    FilterOptions,
+    findAttributeTypeByUri,
+    getSpecialAttrTypeByFieldName,
+    isDateType,
+    mapFilterValue,
+    Metadata,
+    parseTimestamp,
+    SearchFilter,
+    searchUriToAttrUri,
+    wrapInArray
+} from '@reltio/mdm-sdk';
+import {assoc, curry, evolve, includes, map, pipe, prop, when, __} from 'ramda';
+
+export const configFilterToSearchFilter = when(
+    pipe(prop('filter'), includes(__, [FilterOptions.IN_RANGE, FilterOptions.HAS_ALL])),
+    evolve({values: wrapInArray})
+);
+
+export const buildQuery = (
+    filters: DashboardConfigFilter[],
+    globalFilter?: string,
+    searchByOv?: boolean,
+    activityFilter?: string
+): string => {
+    const query = pipe(
+        map(configFilterToSearchFilter),
+        buildFilterQueryString(),
+        addGlobalFilterToQuery(globalFilter)
+    )(filters);
+    const result = query ? [`filter=${query}`] : [];
+    if (searchByOv) {
+        result.push('options=searchByOv');
+    }
+    if (activityFilter) {
+        result.push(`activeness=${activityFilter}`);
+    }
+    return result.join('&');
+};
+
+export const createNotEqualFilter = curry((fieldName: string, value: string) => ({
+    filter: FilterOptions.NOT_EQUALS,
+    values: [value],
+    fieldName
+}));
+
+export const convertSearchFilterToDashboardConfigFilter = (searchFilter: SearchFilter): DashboardConfigFilter => ({
+    filter: searchFilter?.filter ?? FilterOptions.EQUALS,
+    values: (searchFilter?.values ?? []) as string[],
+    fieldName: searchFilter?.fieldName ?? ''
+});
+export const createEntityTypeFilter = (entityTypeUri: string) => ({
+    filter: FilterOptions.EQUALS,
+    fieldName: 'type',
+    values: [entityTypeUri]
+});
+
+export const createFacetItemFilter = curry((fieldName: string, group: string) => ({
+    filter: FilterOptions.EQUALS,
+    values: [group],
+    fieldName
+}));
+
+export const convertFilterToFacetState = curry(
+    (metadata: Metadata, entityType: string, filter: DashboardConfigFilter) => {
+        const {fieldName} = filter;
+        const isEntityAttributeFilter = /^(attributes|analyticsAttributes)/.test(fieldName);
+        const attrType = isEntityAttributeFilter
+            ? findAttributeTypeByUri(metadata, searchUriToAttrUri(fieldName, entityType))
+            : getSpecialAttrTypeByFieldName(fieldName);
+
+        return pipe(
+            configFilterToSearchFilter,
+            when(() => isEntityAttributeFilter, assoc('entityType', entityType)),
+            when(() => isDateType(attrType.type), evolve({values: map(mapFilterValue(parseTimestamp))}))
+        )(filter);
+    }
+);
+
+export const isSomeEntityTypeFilter = ({filter, fieldName}: DashboardConfigFilter) =>
+    filter === FilterOptions.EQUALS && fieldName === 'type';
+
+export const isEntityTypeFilter = ({filter, fieldName, values}: DashboardConfigFilter, entityTypeUri: string) =>
+    filter === FilterOptions.EQUALS && fieldName === 'type' && values?.[0] === entityTypeUri;

package/src/services/period.ts

@@ -0,0 +1,33 @@
+import moment from 'moment';
+import {defaultTo, map, pipe} from 'ramda';
+import {getDateRangeByValue, getDateRangeByDatePeriod, DatePeriod, DateRangeValue} from '@reltio/mdm-sdk';
+import {PeriodStep} from '../types/PeriodStep';
+
+const getStepForTimestampInterval = ([startTime, endTime]) => {
+    return endTime - startTime > +moment.duration(1, 'day') ? PeriodStep.DAY : PeriodStep.HOUR;
+};
+
+const getStepForPeriod = pipe(
+    (period) => getDateRangeByDatePeriod(period, getDashboardDateRangeByValue),
+    getStepForTimestampInterval
+);
+
+type GetDateRangeByValue = (value: DatePeriod | [number, number]) => [number, number];
+export const getDashboardDateRangeByValue: GetDateRangeByValue = (value) => {
+    const currentDate = moment();
+
+    switch (value) {
+        case DateRangeValue.LAST_WEEK:
+            return [moment(currentDate).subtract(6, 'days').valueOf(), currentDate.valueOf()];
+        default:
+            return getDateRangeByValue(value);
+    }
+};
+
+const getValuesDateRange = pipe(
+    getDashboardDateRangeByValue,
+    defaultTo([]),
+    map((value) => value && new Date(value))
+);
+
+export {getStepForPeriod, getValuesDateRange};

package/src/services/savedSearches.ts

@@ -0,0 +1,20 @@
+import {ChartData} from '@reltio/components';
+import {SavedSearchData} from '../types/SavedSearchData';
+
+export const savedSearchDataToChartData = (data: SavedSearchData[]): ChartData[] => {
+    return data.map(({uri, name, count}) => {
+        return {
+            value: count || 0,
+            label: name || '',
+            group: uri
+        };
+    });
+};
+
+export const savedSearchDataToSearchState = ({uiState, uri}: SavedSearchData) => {
+    if (uiState.version === '2.0') {
+        return {...uiState, currentSavedSearchUri: uri};
+    } else {
+        return {...uiState.state, curSavedSearchUri: uri};
+    }
+};

package/src/services/stats.ts

@@ -0,0 +1,191 @@
+import {
+    append,
+    chain,
+    curry,
+    evolve,
+    groupBy,
+    last,
+    map,
+    pipe,
+    pluck,
+    prepend,
+    prop,
+    propEq,
+    propOr,
+    sum,
+    toPairs
+} from 'ramda';
+import moment from 'moment';
+import i18n from 'ui-i18n';
+import {getEntitiesStats, getDateRangeByDatePeriod, DatePeriod} from '@reltio/mdm-sdk';
+import {PeriodStep} from '../types/PeriodStep';
+import {TimestampedStatsEventData, StatsData, StatsEventData} from '../types/StatsData';
+import {getDashboardDateRangeByValue} from '../services/period';
+import {AxisDomain} from 'recharts';
+
+const StatsEvents = [
+    {
+        id: 'created',
+        types: ['CREATED'],
+        get label() {
+            return i18n.text('New');
+        },
+        color: '#4BAFFF'
+    },
+    {
+        id: 'updated',
+        types: ['UPDATED'],
+        get label() {
+            return i18n.text('Updated');
+        },
+        color: '#0072CE'
+    },
+    {
+        id: 'deleted',
+        types: ['DELETED'],
+        get label() {
+            return i18n.text('Deleted');
+        },
+        color: '#F085F2'
+    },
+    {
+        id: 'matched',
+        types: ['POTENTIAL_MATCHES_FOUND'],
+        get label() {
+            return i18n.text('Matched');
+        },
+        color: '#C4CE00'
+    },
+    {
+        id: 'autoMerged',
+        types: ['MERGED', 'MERGED_ON_THE_FLY'],
+        get label() {
+            return i18n.text('Auto-merged');
+        },
+        color: '#CE5C00'
+    },
+    {
+        id: 'mergedManually',
+        types: ['MERGED_MANUALLY'],
+        get label() {
+            return i18n.text('Manually merged');
+        },
+        color: '#9E7ED3'
+    },
+    {
+        id: 'unmerged',
+        types: ['SPLITTED'],
+        get label() {
+            return i18n.text('Unmerged');
+        },
+        color: '#40CFBB'
+    },
+    {
+        id: 'notMatch',
+        types: ['NOT_MATCHES_SET'],
+        get label() {
+            return i18n.text('Not a match');
+        },
+        color: '#F97061'
+    }
+];
+
+const getStatsEventById = (event: string) => StatsEvents.find(propEq('id', event));
+const getStatsEventName = pipe(getStatsEventById, propOr('', 'label'));
+const getStatsEventColor = pipe(getStatsEventById, prop('color'));
+
+const requestStats = (period: DatePeriod): Promise<StatsData[]> => {
+    const [startTime, endTime] = getDateRangeByDatePeriod(period, getDashboardDateRangeByValue);
+    const getStats = ({facet, types}) =>
+        getEntitiesStats({facet, startTime, endTime, types}).then(({facets = {}, total = 0}) => ({
+            total,
+            data: facets[facet]
+        }));
+
+    const getEvents = () => {
+        const allTypes = chain(prop('types'), StatsEvents);
+        const processStats = pipe(propOr([], 'data'), pluck('term'));
+        return getStats({facet: 'type', types: allTypes}).then((stats) => processStats(stats));
+    };
+
+    const getEventsData = (presentTypes) => {
+        const periodFrame = pipe(
+            map(
+                evolve({
+                    term: (term) => moment.utc(term).valueOf()
+                })
+            ),
+            prepend({
+                term: startTime,
+                count: 0
+            }),
+            append({
+                term: endTime,
+                count: 0
+            })
+        );
+        const isEventPresent = (types) => types.some((type) => presentTypes.includes(type));
+
+        return Promise.all(
+            StatsEvents.map(({types, id}) =>
+                (isEventPresent(types) ? getStats({facet: 'hour', types}) : Promise.resolve({total: 0, data: []})).then(
+                    ({total, data}) => ({total, data: periodFrame(data), event: id})
+                )
+            )
+        );
+    };
+
+    return getEvents().then((events) => (events.length > 0 ? getEventsData(events) : []));
+};
+
+const groupEventsData = curry((step: PeriodStep, eventData: StatsEventData[]): TimestampedStatsEventData[] => {
+    return pipe(
+        groupBy(({term}) => moment(term).startOf(step)),
+        toPairs,
+        map(([date, data]) => ({
+            term: moment(date).valueOf(),
+            count: sum(pluck('count', data))
+        }))
+    )(eventData);
+});
+
+const interpolateEventsData = curry(
+    (step: PeriodStep, eventData: TimestampedStatsEventData[]): TimestampedStatsEventData[] => {
+        const [head, ...other] = eventData;
+        return other.reduce(
+            (acc, item) => {
+                const lastTerm = last(acc).term;
+                let nextTerm = moment(lastTerm).add(1, step).valueOf();
+                const interpolatedItems = [];
+                while (nextTerm < item.term) {
+                    interpolatedItems.push({
+                        term: nextTerm,
+                        count: 0
+                    });
+                    nextTerm = moment(nextTerm).add(1, step).valueOf();
+                }
+                return acc.concat(interpolatedItems, item);
+            },
+            [head]
+        );
+    }
+);
+
+const calibrateStatsData = curry((step: PeriodStep, statsData: StatsData[]) => {
+    return statsData.map(
+        evolve({
+            data: pipe(groupEventsData(step), interpolateEventsData(step))
+        })
+    );
+});
+
+const getChartDomain = (chartData: StatsData[], tickCount: number): [AxisDomain, AxisDomain] => {
+    const counts = chain(pipe(prop('data'), pluck('count')))(chartData);
+    const min = Math.min(...counts);
+    const max = Math.max(...counts);
+    const difference = Math.abs(max - min);
+
+    return difference < tickCount ? [0, tickCount - 1] : [0, 'auto'];
+};
+
+export {StatsEvents, requestStats, getStatsEventName, getStatsEventColor, calibrateStatsData, getChartDomain};

package/src/services/workflowTasks.ts

@@ -0,0 +1,116 @@
+import {
+    always,
+    cond,
+    converge,
+    curry,
+    descend,
+    equals,
+    filter,
+    head,
+    isNil,
+    keys,
+    map,
+    otherwise,
+    path,
+    pipe,
+    prop,
+    propEq,
+    propOr,
+    reject,
+    sort,
+    startsWith,
+    T,
+    when,
+    complement,
+    isEmpty
+} from 'ramda';
+import {WorkflowTasksCategories} from '../types/WorkflowTasks';
+import {
+    getDataChangeRequest,
+    getEntitiesByUris,
+    getGroupTasksForTenant,
+    getTasksForTenant,
+    isEntityUri,
+    WorkflowTaskData
+} from '@reltio/mdm-sdk';
+
+const getTasksByCategory = cond([
+    [equals(WorkflowTasksCategories.MY), always(getTasksForTenant)],
+    [equals(WorkflowTasksCategories.TEAM), always(getGroupTasksForTenant)],
+    [T, always(() => Promise.resolve({data: []}))]
+]);
+
+const getFirstObjectUri = pipe(propOr([], 'objectURIs'), head);
+const isDCRObjectUri = startsWith('changeRequests/');
+
+const notEmpty = complement(isEmpty);
+
+const getEntities = pipe(map(getFirstObjectUri), filter(isEntityUri), when(notEmpty, getEntitiesByUris));
+
+const getChangeRequests = pipe(
+    map(getFirstObjectUri),
+    filter(isDCRObjectUri),
+    map(pipe(getDataChangeRequest, otherwise(always(null)))),
+    (requests) => Promise.all(requests)
+);
+
+const getTaskObjectsData = converge((...requests) => Promise.all(requests), [getEntities, getChangeRequests]);
+
+const enrichTaskWithEntity = (entities) => (task) => {
+    const entity = entities.find(propEq('uri', getFirstObjectUri(task)));
+    return entity
+        ? {
+            ...task,
+            objects: [entity]
+        }
+        : task;
+};
+
+const extractObjectsFromChangeRequest = ({objectsInfo = {}, changes = {}, uri}) => {
+    const getChange = (key) => path([key, 0], changes);
+    const getUri = (key) => {
+        const {type} = getChange(key);
+        if (type == 'CREATE_ENTITY' || type == 'CREATE_RELATIONSHIP') {
+            return uri + '/changes/' + key;
+        } else {
+            return key;
+        }
+    };
+    return pipe(
+        keys,
+        filter(getChange),
+        sort(descend(pipe(getChange, prop('createdTime')))),
+        map((key) => ({...objectsInfo[key], uri: getUri(key)}))
+    )(objectsInfo);
+};
+
+const enrichTaskWithDCRObjects = (changeRequests) => (task) => {
+    const changeRequest = changeRequests.find(propEq('uri', getFirstObjectUri(task)));
+    return changeRequest
+        ? {
+            ...task,
+            objects: extractObjectsFromChangeRequest(changeRequest)
+        }
+        : task;
+};
+
+const enrichTasksWithObjectsData = (entities, changeRequests, tasks) => {
+    changeRequests = reject(isNil, changeRequests);
+    return tasks.map(
+        pipe(
+            when(pipe(getFirstObjectUri, isEntityUri), enrichTaskWithEntity(entities)),
+            when(pipe(getFirstObjectUri, isDCRObjectUri), enrichTaskWithDCRObjects(changeRequests))
+        )
+    );
+};
+
+export const requestWorkflowTasks = curry(
+    async (tasksCategory, {workflowPath, environment, tenant, assignee, max, offset}) => {
+        const getTasks = getTasksByCategory(tasksCategory);
+        const {data, total} = await getTasks({workflowPath, environment, tenant, assignee, max, offset});
+        const [entities, changeRequests] = await getTaskObjectsData(data);
+        return {data: enrichTasksWithObjectsData(entities, changeRequests, data), total};
+    }
+);
+
+export const isOverdueTask = (task: WorkflowTaskData) => task.dueDate && task.dueDate < Date.now();

package/src/types/ActivitiesViewFacetConfig.ts

@@ -0,0 +1,5 @@
+import {DashboardView} from '@reltio/mdm-sdk';
+
+export type ActivitiesViewFacetConfig = DashboardView & {
+    exportTypes?: string[];
+};

package/src/types/CustomActionViewFacetConfig.ts

@@ -0,0 +1,5 @@
+import {DashboardView} from '@reltio/mdm-sdk';
+
+export type CustomActionViewFacetConfig = DashboardView & {
+    url: string;
+};

package/src/types/DashboardPerspectiveConfig.ts

@@ -0,0 +1,18 @@
+import {DashboardView as DashboardViewConfig, Layout} from '@reltio/mdm-sdk';
+
+export enum ViewStatus {
+    UPDATED = 'updated',
+    NEW = 'new',
+    PERSISTED = 'persisted'
+}
+
+export type DashboardView = {
+    config: DashboardViewConfig;
+    status: ViewStatus;
+};
+
+export type DashboardPerspectiveLegacyConfig = {
+    id: string;
+    layout: Layout;
+    version: string;
+};

package/src/types/DashboardSavedState.ts

@@ -0,0 +1,7 @@
+import {ReltioGridLayoutItem} from '@reltio/mdm-sdk';
+
+export type DashboardSavedState = {
+    layout?: ReltioGridLayoutItem[];
+    configHash?: string;
+    viewsHashMap?: Record<string, string>;
+};

package/src/types/EntityByTypeViewFacetConfig.ts

@@ -0,0 +1,7 @@
+import {DashboardView} from '@reltio/mdm-sdk';
+
+export type EntityByTypeViewFacetConfig = DashboardView & {
+    orderType?: string;
+    hideEmpty: boolean;
+    inheritChildren: boolean;
+};

package/src/types/EntityData.ts

@@ -0,0 +1,4 @@
+export type EntityData = {
+    uri: string;
+    label: string;
+};

package/src/types/FilteredEntitiesFacetConfig.ts

@@ -0,0 +1,6 @@
+import {DashboardConfigFilter, DashboardView} from '@reltio/mdm-sdk';
+
+export type FilteredEntitiesFacetConfig = DashboardView & {
+    filters?: DashboardConfigFilter[];
+    max?: number;
+};

package/src/types/FilteredSavedSearchesFacetConfig.ts

@@ -0,0 +1,6 @@
+import {DashboardView, SavedSearchesOptions} from '@reltio/mdm-sdk';
+
+export type FilteredSavedSearchesFacetConfig = DashboardView & {
+    options?: SavedSearchesOptions;
+    max?: number;
+};