@reltio/components 1.4.876 → 1.4.880

package/components/workflow/components/WorkflowComments/styles.js

@@ -0,0 +1,105 @@
+import { makeStyles } from '@material-ui/core/styles';
+export var useCommentStyles = makeStyles(function (_theme) { return ({
+    comment: {
+        display: 'flex',
+        flexDirection: 'row',
+        flex: 1,
+        marginLeft: '6px'
+    },
+    avatar: {
+        height: '24px',
+        width: '24px',
+        margin: '3px 13px 0 0'
+    },
+    icon: {
+        fill: '#537280',
+        backgroundColor: '#EAEDEE'
+    },
+    firstLine: {
+        display: 'flex',
+        flexDirection: 'row'
+    },
+    info: {
+        flex: 1
+    },
+    author: {
+        flex: 1,
+        fontWeight: '500',
+        color: 'rgba(0,0,0,0.87)',
+        fontSize: '13px',
+        lineHeight: '15px'
+    },
+    date: {
+        color: 'rgba(0, 0, 0, 0.54)',
+        fontSize: '11px',
+        marginRight: '17px',
+        lineHeight: '15px'
+    },
+    text: {
+        color: 'rgba(0, 0, 0, 0.6)',
+        fontSize: '13px',
+        wordWrap: 'break-word'
+    }
+}); });
+export var useCollapsedCommentsStyles = makeStyles(function (_theme) { return ({
+    circleButton: {
+        maxWidth: '14px',
+        maxHeight: '14px',
+        border: '1px solid rgba(0, 0, 0, 0.3)',
+        fontSize: '13px',
+        color: 'rgba(0, 0, 0, 0.6)',
+        position: 'absolute',
+        top: '-11px',
+        left: '5px',
+        backgroundColor: '#ffffff',
+        '&:hover': {
+            backgroundColor: '#f7f7f7'
+        },
+        '&.focused': {
+            backgroundColor: '#f7f7f7'
+        }
+    },
+    delimiter: {
+        position: 'relative',
+        height: '4px',
+        borderTop: '1px solid rgba(0, 0, 0, 0.3)',
+        borderBottom: '1px solid rgba(0, 0, 0, 0.3)',
+        margin: '15px 0 24px 0'
+    }
+}); });
+export var useWorkflowStyles = makeStyles(function (_theme) { return ({
+    container: {
+        padding: '5px 0',
+        display: 'flex',
+        flexDirection: 'column'
+    },
+    commentsContainer: {
+        maxHeight: '300px',
+        overflowY: 'auto'
+    },
+    title: {
+        margin: '0 0 8px 5px',
+        fontSize: '14px',
+        color: 'rgba(0, 0, 0, 0.87)'
+    },
+    filledInputRoot: {
+        backgroundColor: 'rgba(0, 0, 0, 0.03)',
+        padding: '0 6px',
+        height: '40px',
+        margin: '10px 17px 0 6px',
+        fontSize: '14px',
+        '&:hover': {
+            backgroundColor: 'rgba(0, 0, 0, 0.03)'
+        },
+        '&.focused': {
+            backgroundColor: 'rgba(0, 0, 0, 0.03)'
+        }
+    }
+}); });
+export var useExpandedComments = makeStyles(function (_theme) { return ({
+    messageContainer: {
+        borderBottom: '1px solid rgba(0,0,0,0.3)',
+        paddingBottom: '7px',
+        marginBottom: '7px'
+    }
+}); });

package/components/workflow/helpers/errors.d.ts

@@ -0,0 +1,2 @@
+import { ApiError } from '@reltio/mdm-sdk';
+export declare const showWorkflowError: (error?: ApiError) => void;

package/components/workflow/helpers/errors.js

@@ -0,0 +1,14 @@
+import i18n from 'ui-i18n';
+import { ApiErrorCode } from '@reltio/mdm-sdk';
+import ErrorPopup from '../../ErrorPopup/ErrorPopup';
+export var showWorkflowError = function (error) {
+    if (error === void 0) { error = {}; }
+    var errorMessage = error.errorMessage, errorCode = error.errorCode;
+    if (errorCode !== ApiErrorCode.WORKFLOW_IS_NOT_REGISTERED_ERROR) {
+        console.error(error); // eslint-disable-line
+        ErrorPopup.addError({
+            title: i18n.text('Error'),
+            message: errorMessage || i18n.text('Something went wrong...')
+        });
+    }
+};

package/components/workflow/helpers/index.d.ts

@@ -0,0 +1,3 @@
+declare const getDCRUri: (objectUris?: string[]) => string;
+declare const getDCRId: (objectUris?: string[]) => string;
+export { getDCRUri, getDCRId };

package/components/workflow/helpers/index.js

@@ -0,0 +1,10 @@
+import { pipe, startsWith, isNil, unless, split, nth } from 'ramda';
+var getDCRUri = function (objectUris) {
+    if (objectUris === void 0) { objectUris = []; }
+    return objectUris.find(startsWith('changeRequests/'));
+};
+var getDCRId = function (objectUris) {
+    if (objectUris === void 0) { objectUris = []; }
+    return pipe(getDCRUri, unless(isNil, pipe(split('/'), nth(1))))(objectUris);
+};
+export { getDCRUri, getDCRId };

package/components/workflow/hooks/useWorkflowActions.d.ts

@@ -0,0 +1,10 @@
+import { WorkflowTaskData } from '@reltio/mdm-sdk';
+declare type TaskAction = {
+    text: string;
+    onClick: () => void;
+};
+export declare const useWorkflowActions: ({ possibleActions, assignee, taskId }: Pick<WorkflowTaskData, 'taskId' | 'possibleActions' | 'assignee'>) => {
+    actions: TaskAction[];
+    actionRequestIsInProgress: boolean;
+};
+export {};

package/components/workflow/hooks/useWorkflowActions.js

@@ -0,0 +1,57 @@
+import { useCallback, useContext, useMemo, useState } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { runTaskAction } from '@reltio/mdm-sdk';
+import mdmModule, { profile, ui } from '@reltio/mdm-module';
+import { ViewIdContext } from '../../../contexts/ViewIdContext';
+import { showWorkflowError } from '../helpers/errors';
+import { WorkflowTasksContext } from '../../../contexts/WorkflowTasksContext';
+export var useWorkflowActions = function (_a) {
+    var possibleActions = _a.possibleActions, assignee = _a.assignee, taskId = _a.taskId;
+    var loadWorkflowTasks = (useContext(WorkflowTasksContext) || {}).loadWorkflowTasks;
+    var workflowPath = useSelector(mdmModule.selectors.getWorkflowPath);
+    var environment = useSelector(mdmModule.selectors.getWorkflowEnvironmentUrl);
+    var tenant = useSelector(mdmModule.selectors.getTenant);
+    var username = useSelector(mdmModule.selectors.getUserName);
+    var entityUri = useSelector(mdmModule.selectors.getEntityUri);
+    var _b = useState(false), actionRequestIsInProgress = _b[0], setActionRequestIsInProgress = _b[1];
+    var viewId = useContext(ViewIdContext);
+    var dispatch = useDispatch();
+    var performTaskAction = useCallback(function (action) { return function () {
+        if (workflowPath && taskId) {
+            setActionRequestIsInProgress(true);
+            runTaskAction({
+                taskId: taskId,
+                workflowPath: workflowPath,
+                environment: environment,
+                tenant: tenant,
+                action: action
+            })
+                .then(function () {
+                if (action === 'Delete') {
+                    dispatch(ui.actions.entityDeletionFinished());
+                }
+                else {
+                    // entity refreshing
+                    dispatch(profile.entity.actions.loadEntity({ viewId: viewId, uri: entityUri }));
+                    loadWorkflowTasks === null || loadWorkflowTasks === void 0 ? void 0 : loadWorkflowTasks();
+                }
+            })
+                .catch(showWorkflowError)
+                .finally(function () {
+                setActionRequestIsInProgress(false);
+            });
+        }
+    }; }, [workflowPath, taskId, environment, tenant, dispatch, entityUri, viewId, loadWorkflowTasks]);
+    var actions = useMemo(function () {
+        return username === assignee
+            ? (possibleActions || []).map(function (_a) {
+                var action = _a.action, label = _a.label;
+                return ({
+                    text: label,
+                    onClick: performTaskAction(action)
+                });
+            })
+            : [];
+    }, [possibleActions, performTaskAction, username, assignee]);
+    return { actions: actions, actionRequestIsInProgress: actionRequestIsInProgress };
+};

package/components/workflow/hooks/useWorkflowAssignee.d.ts

@@ -0,0 +1,13 @@
+import { WorkflowTaskData } from '@reltio/mdm-sdk';
+declare type AssigneeOption = {
+    label: string;
+    value: string;
+};
+export declare const useWorkflowAssignee: ({ assignee, taskId }: Pick<WorkflowTaskData, 'taskId' | 'assignee'>) => {
+    assignee: AssigneeOption;
+    getAssignees: (text: any) => Promise<void | unknown[]>;
+    updateAssignee: (newValue: AssigneeOption) => void;
+    updateRequestIsInProgress: boolean;
+    readOnly: boolean;
+};
+export {};

package/components/workflow/hooks/useWorkflowAssignee.js

@@ -0,0 +1,83 @@
+import { useState, useEffect, useCallback, useContext } from 'react';
+import { filter } from 'ramda';
+import { useSelector } from 'react-redux';
+import { getAssigneeForTask, updateAssigneeForTask } from '@reltio/mdm-sdk';
+import mdmModule from '@reltio/mdm-module';
+import { useSafePromise } from '../../../hooks';
+import { WorkflowTasksContext } from '../../../contexts/WorkflowTasksContext';
+import { showWorkflowError } from '../helpers/errors';
+import { useWorkflowCheckPermission } from './useWorkflowCheckPermission';
+var assigneeToValue = function (assignee) { return ({
+    label: assignee,
+    value: assignee
+}); };
+export var useWorkflowAssignee = function (_a) {
+    var assignee = _a.assignee, taskId = _a.taskId;
+    var updateTaskState = (useContext(WorkflowTasksContext) || {}).updateTaskState;
+    var workflowPath = useSelector(mdmModule.selectors.getWorkflowPath);
+    var environment = useSelector(mdmModule.selectors.getWorkflowEnvironmentUrl);
+    var tenant = useSelector(mdmModule.selectors.getTenant);
+    var updateSafePromise = useSafePromise();
+    var getSafePromise = useSafePromise();
+    var _b = useState(null), currentAssignee = _b[0], setCurrentAssignee = _b[1];
+    var _c = useState(), assignees = _c[0], setAssignees = _c[1];
+    var _d = useState(false), updateRequestIsInProgress = _d[0], setUpdateRequestIsInProgress = _d[1];
+    var checkWorkflowPermission = useWorkflowCheckPermission();
+    var canUpdateTask = checkWorkflowPermission('UPDATE_TASK');
+    useEffect(function () {
+        setCurrentAssignee(assigneeToValue(assignee));
+    }, [assignee]);
+    var getAssignees = useCallback(function (text) {
+        if (workflowPath && canUpdateTask && taskId) {
+            var filterOutRest_1 = filter(function (item) { return item.value.toLowerCase().includes(text); });
+            if (assignees) {
+                return Promise.resolve(filterOutRest_1(assignees));
+            }
+            return getSafePromise(getAssigneeForTask({
+                taskId: taskId,
+                workflowPath: workflowPath,
+                environment: environment,
+                tenant: tenant
+            }))
+                .then(function (result) {
+                var data = result.data;
+                var assignees = data.map(assigneeToValue);
+                setAssignees(assignees);
+                return filterOutRest_1(assignees);
+            })
+                .catch(showWorkflowError);
+        }
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [workflowPath, taskId, environment, tenant, assignees, setAssignees, canUpdateTask]);
+    var updateAssignee = useCallback(function (newValue) {
+        if (workflowPath && canUpdateTask && taskId) {
+            var assignee_1 = newValue.value;
+            setUpdateRequestIsInProgress(true);
+            updateSafePromise(updateAssigneeForTask({
+                taskId: taskId,
+                workflowPath: workflowPath,
+                environment: environment,
+                tenant: tenant,
+                assignee: assignee_1
+            }))
+                .then(function () {
+                setCurrentAssignee(assigneeToValue(assignee_1));
+                updateTaskState === null || updateTaskState === void 0 ? void 0 : updateTaskState(taskId, { assignee: assignee_1 });
+            })
+                .catch(showWorkflowError)
+                .finally(function () {
+                setUpdateRequestIsInProgress(false);
+            });
+        }
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [workflowPath, taskId, environment, tenant, canUpdateTask]);
+    return {
+        assignee: currentAssignee,
+        getAssignees: getAssignees,
+        updateAssignee: updateAssignee,
+        updateRequestIsInProgress: updateRequestIsInProgress,
+        readOnly: !canUpdateTask
+    };
+};

package/components/workflow/hooks/useWorkflowCheckPermission.d.ts

@@ -0,0 +1 @@
+export declare const useWorkflowCheckPermission: () => (permission: string) => boolean;

package/components/workflow/hooks/useWorkflowCheckPermission.js

@@ -0,0 +1,84 @@
+import { useSelector } from 'react-redux';
+import mdmModule from '@reltio/mdm-module';
+export var useWorkflowCheckPermission = function () {
+    var workflowPath = useSelector(mdmModule.selectors.getWorkflowPath);
+    var canUserStartProcessFromQuery = useSelector(mdmModule.selectors.getCanUserStartProcessFromQuery);
+    var canUserViewWorkflowJobs = useSelector(mdmModule.selectors.getCanUserViewWorkflowJobs);
+    var canUserViewWorkflowEnvironmentConfigJar = useSelector(mdmModule.selectors.getCanUserViewWorkflowEnvironmentConfigJar);
+    var canUserViewWorkflowDefinition = useSelector(mdmModule.selectors.getCanUserViewWorkflowDefinition);
+    var canUserViewWorkflowConfigJar = useSelector(mdmModule.selectors.getCanUserViewWorkflowConfigJar);
+    var canUserViewProcessInstanceSearchQuery = useSelector(mdmModule.selectors.getCanUserViewProcessInstanceSearchQuery);
+    var canUserUpdateWorkflowDataTask = useSelector(mdmModule.selectors.getCanUserUpdateWorkflowDataTask);
+    var canUserUpdateProcessInstance = useSelector(mdmModule.selectors.getCanUserUpdateProcessInstance);
+    var canUserReadWorkflowDataTask = useSelector(mdmModule.selectors.getCanUserReadWorkflowDataTask);
+    var canUserManageWorkflowEnvironmentDefinition = useSelector(mdmModule.selectors.getCanUserManageWorkflowEnvironmentDefinition);
+    var canUserManageWorkflowDefinition = useSelector(mdmModule.selectors.getCanUserManageWorkflowDefinition);
+    var canUserExecuteWorkflowJobsValidateTasks = useSelector(mdmModule.selectors.getCanUserExecuteWorkflowJobsValidateTasks);
+    var canUserExecuteWorkflowJobsUpdateTasks = useSelector(mdmModule.selectors.getCanUserExecuteWorkflowJobsUpdateTasks);
+    var canUserExecuteWorkflowJobsTerminateProcessInstance = useSelector(mdmModule.selectors.getCanUserExecuteWorkflowJobsTerminateProcessInstance);
+    var canUserExecuteWorkflowJobsSyncBusinessProcessData = useSelector(mdmModule.selectors.getCanUserExecuteWorkflowJobsSyncBusinessProcessData);
+    var canUserExecuteWorkflowJobs = useSelector(mdmModule.selectors.getCanUserExecuteWorkflowJobs);
+    var canUserCreateWorkflowEnvironmentConfigJar = useSelector(mdmModule.selectors.getCanUserCreateWorkflowEnvironmentConfigJar);
+    var canUserRegisterConfigEnvironments = useSelector(mdmModule.selectors.getCanUserRegisterConfigEnvironments);
+    var canUserCreateWorkflowConfigJar = useSelector(mdmModule.selectors.getCanUserCreateWorkflowConfigJar);
+    var checkWorkflowPermission = function (permission) {
+        if (!workflowPath)
+            return false;
+        switch (permission) {
+            case 'VIEW_PROCESS_DEFINITIONS': {
+                return canUserViewWorkflowDefinition;
+            }
+            case 'DEPLOY_GENERIC_PROCESS_DEFINITION': {
+                return canUserManageWorkflowEnvironmentDefinition;
+            }
+            case 'VIEW_JOBS': {
+                return canUserViewWorkflowJobs;
+            }
+            case 'START_JOB': {
+                return (canUserExecuteWorkflowJobs ||
+                    (canUserExecuteWorkflowJobsSyncBusinessProcessData &&
+                        canUserExecuteWorkflowJobsTerminateProcessInstance &&
+                        canUserExecuteWorkflowJobsUpdateTasks &&
+                        canUserExecuteWorkflowJobsValidateTasks));
+            }
+            case 'VIEW_CUSTOM_JARS': {
+                return canUserViewWorkflowConfigJar || canUserViewWorkflowEnvironmentConfigJar;
+            }
+            case 'UPDATE_PROCESS_INSTANCE': {
+                return canUserUpdateProcessInstance;
+            }
+            case 'VIEW_TASKS': {
+                return canUserReadWorkflowDataTask;
+            }
+            case 'REGISTER_TENANT': {
+                return canUserRegisterConfigEnvironments;
+            }
+            case 'START_PROCESS_INSTANCE': {
+                return canUserStartProcessFromQuery;
+            }
+            case 'VIEW_PROCESS_INSTANCE_COMMENTS': {
+                return canUserViewProcessInstanceSearchQuery;
+            }
+            case 'VIEW_PROCESS_INSTANCES': {
+                return canUserViewProcessInstanceSearchQuery;
+            }
+            case 'UPDATE_TASK': {
+                return canUserUpdateWorkflowDataTask;
+            }
+            case 'DEPLOY_TENANT_PROCESS_DEFINITION': {
+                return canUserManageWorkflowDefinition;
+            }
+            case 'DEPLOY_CUSTOM_JAR': {
+                return canUserCreateWorkflowConfigJar && canUserCreateWorkflowEnvironmentConfigJar;
+            }
+            case 'START_PROCESS_INSTANCE_SEARCH_QUERY': {
+                return canUserStartProcessFromQuery;
+            }
+            case 'VIEW_PROCESS_INSTANCE_COUNT': {
+                return canUserViewProcessInstanceSearchQuery;
+            }
+        }
+        return false;
+    };
+    return checkWorkflowPermission;
+};

package/components/workflow/hooks/useWorkflowColor.d.ts

@@ -0,0 +1,3 @@
+import { WorkflowTaskData } from '@reltio/mdm-sdk';
+export declare const resetTaskToColor: () => void;
+export declare const useWorkflowColor: ({ processDefinitionDisplayName }: Pick<WorkflowTaskData, 'processDefinitionDisplayName'>) => any;

package/components/workflow/hooks/useWorkflowColor.js

@@ -0,0 +1,31 @@
+var taskToColor = {};
+var COLORS = [
+    '#DC057B',
+    '#5DC003',
+    '#FEC92F',
+    '#F57F27',
+    '#B71137',
+    '#056B97',
+    '#4499AE',
+    '#BD81BE',
+    '#5F3577',
+    '#A68560',
+    '#555962'
+];
+var colorIndex = 0;
+export var resetTaskToColor = function () {
+    taskToColor = {};
+    colorIndex = 0;
+};
+export var useWorkflowColor = function (_a) {
+    var processDefinitionDisplayName = _a.processDefinitionDisplayName;
+    var hash = processDefinitionDisplayName;
+    if (!taskToColor[hash]) {
+        taskToColor[hash] = COLORS[colorIndex];
+        colorIndex++;
+        if (colorIndex > COLORS.length - 1) {
+            colorIndex = 0;
+        }
+    }
+    return taskToColor[hash];
+};

package/components/workflow/hooks/useWorkflowComments.d.ts

@@ -0,0 +1,7 @@
+import { WorkflowTaskData } from '@reltio/mdm-sdk';
+export declare const useWorkflowComments: ({ processInstanceComments, taskId }: WorkflowTaskData) => {
+    comments: any[];
+    requestIsInProgress: boolean;
+    writeComment: (comment: any) => void;
+    readOnly: boolean;
+};

package/components/workflow/hooks/useWorkflowComments.js

@@ -0,0 +1,50 @@
+import { useState, useEffect, useCallback, useContext } from 'react';
+import { addCommentForTask, getTaskById } from '@reltio/mdm-sdk';
+import mdmModule from '@reltio/mdm-module';
+import { useSelector } from 'react-redux';
+import { useSafePromise } from '../../../hooks';
+import { WorkflowTasksContext } from '../../../contexts/WorkflowTasksContext';
+import { showWorkflowError } from '../helpers/errors';
+import { useWorkflowCheckPermission } from './useWorkflowCheckPermission';
+export var useWorkflowComments = function (_a) {
+    var processInstanceComments = _a.processInstanceComments, taskId = _a.taskId;
+    var updateTaskState = (useContext(WorkflowTasksContext) || {}).updateTaskState;
+    var workflowPath = useSelector(mdmModule.selectors.getWorkflowPath);
+    var environment = useSelector(mdmModule.selectors.getWorkflowEnvironmentUrl);
+    var tenant = useSelector(mdmModule.selectors.getTenant);
+    var safePromise = useSafePromise();
+    var _b = useState([]), comments = _b[0], setComments = _b[1];
+    var _c = useState(false), requestIsInProgress = _c[0], setRequestIsInProgress = _c[1];
+    var checkWorkflowPermission = useWorkflowCheckPermission();
+    var canUpdateTask = checkWorkflowPermission('UPDATE_TASK');
+    useEffect(function () {
+        setComments(processInstanceComments || []);
+    }, [processInstanceComments]);
+    var writeComment = useCallback(function (comment) {
+        if (canUpdateTask) {
+            setRequestIsInProgress(true);
+            safePromise(addCommentForTask({
+                workflowPath: workflowPath,
+                environment: environment,
+                tenant: tenant,
+                taskId: taskId,
+                comment: comment
+            }).then(function () {
+                return getTaskById({
+                    workflowPath: workflowPath,
+                    environment: environment,
+                    tenant: tenant,
+                    taskId: taskId
+                });
+            }))
+                .then(function (_a) {
+                var processInstanceComments = _a.processInstanceComments;
+                setComments(processInstanceComments || []);
+                updateTaskState === null || updateTaskState === void 0 ? void 0 : updateTaskState(taskId, { processInstanceComments: processInstanceComments });
+            })
+                .catch(showWorkflowError)
+                .finally(function () { return setRequestIsInProgress(false); });
+        }
+    }, [environment, taskId, tenant, workflowPath, safePromise, updateTaskState, canUpdateTask]);
+    return { comments: comments, requestIsInProgress: requestIsInProgress, writeComment: writeComment, readOnly: !canUpdateTask };
+};

package/components/workflow/hooks/useWorkflowDueDate.d.ts

@@ -0,0 +1,6 @@
+import { WorkflowTaskData } from '@reltio/mdm-sdk';
+export declare const useWorkflowDueDate: ({ dueDate, taskId }: Pick<WorkflowTaskData, 'dueDate' | 'taskId'>) => {
+    updateDueDate: (newValue: number) => void;
+    updateRequestIsInProgress: boolean;
+    readOnly: boolean;
+};

package/components/workflow/hooks/useWorkflowDueDate.js

@@ -0,0 +1,39 @@
+import { useState, useCallback, useContext } from 'react';
+import { useSelector } from 'react-redux';
+import { updateDueDateForTask } from '@reltio/mdm-sdk';
+import mdmModule from '@reltio/mdm-module';
+import { useSafePromise } from '../../../hooks';
+import { WorkflowTasksContext } from '../../../contexts/WorkflowTasksContext';
+import { showWorkflowError } from '../helpers/errors';
+import { useWorkflowCheckPermission } from './useWorkflowCheckPermission';
+export var useWorkflowDueDate = function (_a) {
+    var dueDate = _a.dueDate, taskId = _a.taskId;
+    var updateTaskState = (useContext(WorkflowTasksContext) || {}).updateTaskState;
+    var workflowPath = useSelector(mdmModule.selectors.getWorkflowPath);
+    var environment = useSelector(mdmModule.selectors.getWorkflowEnvironmentUrl);
+    var tenant = useSelector(mdmModule.selectors.getTenant);
+    var safePromise = useSafePromise();
+    var _b = useState(false), updateRequestIsInProgress = _b[0], setUpdateRequestIsInProgress = _b[1];
+    var checkWorkflowPermission = useWorkflowCheckPermission();
+    var canUpdateTask = checkWorkflowPermission('UPDATE_TASK');
+    var updateDueDate = useCallback(function (newValue) {
+        if (workflowPath && canUpdateTask && taskId && newValue && dueDate !== newValue) {
+            setUpdateRequestIsInProgress(true);
+            safePromise(updateDueDateForTask({
+                taskId: taskId,
+                workflowPath: workflowPath,
+                environment: environment,
+                tenant: tenant,
+                dueDate: newValue
+            }))
+                .then(function () {
+                updateTaskState === null || updateTaskState === void 0 ? void 0 : updateTaskState(taskId, { dueDate: newValue });
+            })
+                .catch(showWorkflowError)
+                .finally(function () {
+                setUpdateRequestIsInProgress(false);
+            });
+        }
+    }, [workflowPath, taskId, environment, tenant, updateTaskState, safePromise, dueDate, canUpdateTask]);
+    return { updateDueDate: updateDueDate, updateRequestIsInProgress: updateRequestIsInProgress, readOnly: !canUpdateTask };
+};

package/components/workflow/hooks/useWorkflowPriority.d.ts

@@ -0,0 +1,12 @@
+import { WorkflowTaskData } from '@reltio/mdm-sdk';
+declare type PriorityOption = {
+    label: string;
+    value: number;
+};
+export declare const useWorkflowPriority: ({ priority, taskId }: Pick<WorkflowTaskData, 'taskId' | 'priority'>) => {
+    priorities: PriorityOption[];
+    updatePriority: (newValue: PriorityOption) => void;
+    updateRequestIsInProgress: boolean;
+    readOnly: boolean;
+};
+export {};

package/components/workflow/hooks/useWorkflowPriority.js

@@ -0,0 +1,59 @@
+import { useState, useCallback, useContext, useMemo } from 'react';
+import { useSelector } from 'react-redux';
+import i18n from 'ui-i18n';
+import { updatePriorityForTask, WorkflowPriority } from '@reltio/mdm-sdk';
+import mdmModule from '@reltio/mdm-module';
+import { useSafePromise } from '../../../hooks';
+import { WorkflowTasksContext } from '../../../contexts/WorkflowTasksContext';
+import { showWorkflowError } from '../helpers/errors';
+import { useWorkflowCheckPermission } from './useWorkflowCheckPermission';
+export var useWorkflowPriority = function (_a) {
+    var priority = _a.priority, taskId = _a.taskId;
+    var updateTaskState = (useContext(WorkflowTasksContext) || {}).updateTaskState;
+    var workflowPath = useSelector(mdmModule.selectors.getWorkflowPath);
+    var environment = useSelector(mdmModule.selectors.getWorkflowEnvironmentUrl);
+    var tenant = useSelector(mdmModule.selectors.getTenant);
+    var safePromise = useSafePromise();
+    var _b = useState(false), updateRequestIsInProgress = _b[0], setUpdateRequestIsInProgress = _b[1];
+    var checkWorkflowPermission = useWorkflowCheckPermission();
+    var canUpdateTask = checkWorkflowPermission('UPDATE_TASK');
+    var updatePriority = useCallback(function (newValue) {
+        var newPriority = newValue.value;
+        if (workflowPath && canUpdateTask && taskId && priority !== newPriority) {
+            setUpdateRequestIsInProgress(true);
+            safePromise(updatePriorityForTask({
+                taskId: taskId,
+                workflowPath: workflowPath,
+                environment: environment,
+                tenant: tenant,
+                priority: newPriority
+            }))
+                .then(function () {
+                updateTaskState === null || updateTaskState === void 0 ? void 0 : updateTaskState(taskId, { priority: newPriority });
+            })
+                .catch(showWorkflowError)
+                .finally(function () {
+                setUpdateRequestIsInProgress(false);
+            });
+        }
+    }, [workflowPath, taskId, environment, tenant, updateTaskState, safePromise, priority, canUpdateTask]);
+    var priorities = useMemo(function () { return [
+        {
+            label: i18n.text('Low'),
+            value: WorkflowPriority.low
+        },
+        {
+            label: i18n.text('Medium'),
+            value: WorkflowPriority.medium
+        },
+        {
+            label: i18n.text('High'),
+            value: WorkflowPriority.high
+        },
+        {
+            label: i18n.text('Urgent'),
+            value: WorkflowPriority.urgent
+        }
+    ]; }, []);
+    return { priorities: priorities, updatePriority: updatePriority, updateRequestIsInProgress: updateRequestIsInProgress, readOnly: !canUpdateTask };
+};

package/components/workflow/index.d.ts

@@ -0,0 +1,5 @@
+export { WorkflowTaskCard } from './cards/WorkflowTaskCard';
+export { default as WorkflowComments } from './components/WorkflowComments';
+export { useWorkflowAssignee } from './hooks/useWorkflowAssignee';
+export { useWorkflowComments } from './hooks/useWorkflowComments';
+export { useWorkflowCheckPermission } from './hooks/useWorkflowCheckPermission';

package/components/workflow/index.js

@@ -0,0 +1,5 @@
+export { WorkflowTaskCard } from './cards/WorkflowTaskCard';
+export { default as WorkflowComments } from './components/WorkflowComments';
+export { useWorkflowAssignee } from './hooks/useWorkflowAssignee';
+export { useWorkflowComments } from './hooks/useWorkflowComments';
+export { useWorkflowCheckPermission } from './hooks/useWorkflowCheckPermission';

package/constants/attributes.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALWAYS_VISIBLE_TYPE_URIS = void 0;
-var mdm_sdk_1 = require("@reltio/mdm-sdk");
-exports.ALWAYS_VISIBLE_TYPE_URIS = [mdm_sdk_1.EntityAttrTypes.roles.uri, mdm_sdk_1.EntityAttrTypes.tags.uri];
+import { EntityAttrTypes } from '@reltio/mdm-sdk';
+export var ALWAYS_VISIBLE_TYPE_URIS = [EntityAttrTypes.roles.uri, EntityAttrTypes.tags.uri];

package/constants/classnames.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMMENTS_CONTAINER_VISIBILITY_AREA = void 0;
-exports.COMMENTS_CONTAINER_VISIBILITY_AREA = 'commentsContainerVisibilityArea';
+export var COMMENTS_CONTAINER_VISIBILITY_AREA = 'commentsContainerVisibilityArea';