@reltio/components 1.4.2253 → 1.4.2254

package/features/workflow/ReviewDCRDialog/ReviewDCRDialog.js

@@ -1,8 +1,9 @@
-import React from 'react';
+import React, { useCallback } from 'react';
 import Dialog from '@mui/material/Dialog';
 import DialogTitle from '@mui/material/DialogTitle';
 import DialogContent from '@mui/material/DialogContent';
 import Typography from '@mui/material/Typography';
+import { useContextSelector } from '@fluentui/react-context-selector';
 import { SmallIconButtonWithTooltip } from '../../../SmallIconButton';
 import CloseIcon from '@mui/icons-material/Close';
 import i18n from 'ui-i18n';
@@ -19,13 +20,22 @@ import { DCRSummaryInfo } from './components/DCRSummaryInfo/DCRSummaryInfo';
 import { ChangeRequestEditor } from '../ChangeRequestEditor';
 import { useApplyDcrChanges } from '../hooks/useApplyDcrChanges';
 import { DCRErrorsPanel } from './DCRErrorsPanel/DCRErrorsPanel';
+import { AddedAttributesContext } from '../contexts/AddedAttributesContext';
+import { ChangeRequestEditorContext } from '../contexts/ChangeRequestEditorContext';
 import styles from './ReviewDCRDialog.module.css';
 export var ReviewDCRDialog = function (_a) {
-    var open = _a.open, onClose = _a.onClose, dcr = _a.dcr, task = _a.task, groupedObjects = _a.groupedObjects;
+    var open = _a.open, onClose = _a.onClose, dcr = _a.dcr, task = _a.task, groupedObjects = _a.groupedObjects, onReloadDcr = _a.onReloadDcr;
     var entity = useMdmEntity();
     var checkWorkflowPermission = useWorkflowCheckPermission();
     var canViewComments = checkWorkflowPermission('VIEW_PROCESS_INSTANCE_COMMENTS');
     var applyDcrChanges = useApplyDcrChanges(dcr);
+    var resetAddedAttributes = useContextSelector(AddedAttributesContext, function (ctx) { return ctx.resetState; });
+    var resetEditorState = useContextSelector(ChangeRequestEditorContext, function (ctx) { return ctx.resetState; });
+    var handleError = useCallback(function () {
+        resetAddedAttributes();
+        resetEditorState();
+        onReloadDcr === null || onReloadDcr === void 0 ? void 0 : onReloadDcr();
+    }, [resetAddedAttributes, resetEditorState, onReloadDcr]);
     var _b = useWorkflowActions({
         task: {
             taskId: task.taskId,
@@ -33,7 +43,8 @@ export var ReviewDCRDialog = function (_a) {
             assignee: task.assignee,
             isOpen: task.isOpen
         },
-        beforeAction: applyDcrChanges
+        beforeAction: applyDcrChanges,
+        onError: handleError
     }), workflowActions = _b.actions, actionRequestIsInProgress = _b.actionRequestIsInProgress;
     return (React.createElement(Dialog, { open: open, onClose: onClose, fullScreen: true },
         React.createElement(DialogTitle, { className: styles.dialogTitle },

package/features/workflow/WorkflowTaskCard/components/DataChangeRequestTaskCard/DataChangeRequestTaskCard.js

@@ -26,7 +26,7 @@ export var DataChangeRequestTaskCard = function (_a) {
     var _b = useState(false), isReviewDCRDialogOpen = _b[0], setIsReviewDCRDialogOpen = _b[1];
     var objectURIs = task.objectURIs, assignee = task.assignee;
     var dcrUri = getDCRUri(objectURIs);
-    var _c = useChangeRequest(dcrUri), dcr = _c.dcr, groupedObjects = _c.groupedObjects;
+    var _c = useChangeRequest(dcrUri), dcr = _c.dcr, groupedObjects = _c.groupedObjects, reloadDcr = _c.reloadDcr;
     var handleReviewDCR = useCallback(function () {
         setIsReviewDCRDialogOpen(true);
     }, []);
@@ -44,5 +44,5 @@ export var DataChangeRequestTaskCard = function (_a) {
             React.createElement(ChangeRequestEditorProvider, null,
                 React.createElement(ScrollToElementProvider, null,
                     React.createElement(ScrollToAddedAttributeProvider, null,
-                        React.createElement(ReviewDCRDialog, { open: isReviewDCRDialogOpen, onClose: handleCloseReviewDCRDialog, dcr: dcr, groupedObjects: groupedObjects, task: task }))))))));
+                        React.createElement(ReviewDCRDialog, { open: isReviewDCRDialogOpen, onClose: handleCloseReviewDCRDialog, dcr: dcr, groupedObjects: groupedObjects, task: task, onReloadDcr: reloadDcr }))))))));
 };

package/features/workflow/contexts/AddedAttributesContext/index.d.ts

@@ -32,6 +32,7 @@ export type AddedAttributesContextType = {
     }) => string[];
     removeAddedAttribute: (id: string) => void;
     updateAddedAttributeRefEntity: (id: string, refEntity: ConnectionEntity) => void;
+    resetState: () => void;
 };
 export declare const AddedAttributesContext: import("@fluentui/react-context-selector").Context<AddedAttributesContextType>;
 export declare const AddedAttributesProvider: ({ children }: {

package/features/workflow/contexts/AddedAttributesContext/index.js

@@ -30,7 +30,8 @@ export var AddedAttributesContext = createContext({
     getAddedAttributes: undefined,
     addAddedAttributes: undefined,
     removeAddedAttribute: undefined,
-    updateAddedAttributeRefEntity: undefined
+    updateAddedAttributeRefEntity: undefined,
+    resetState: undefined
 });
 var getInitialAttributeValue = function (attrType) {
     if (isComplexAttribute(attrType) || isImage(attrType))
@@ -115,11 +116,15 @@ export var AddedAttributesProvider = function (_a) {
     var updateAddedAttributeRefEntity = useCallback(function (id, refEntity) {
         setState(function (prev) { return prev.map(function (attr) { return (attr.id === id ? __assign(__assign({}, attr), { refEntity: refEntity }) : attr); }); });
     }, []);
+    var resetState = useCallback(function () {
+        setState([]);
+    }, []);
     var value = useMemo(function () { return ({
         getAddedAttributes: getAddedAttributes,
         addAddedAttributes: addAddedAttributes,
         removeAddedAttribute: removeAddedAttribute,
-        updateAddedAttributeRefEntity: updateAddedAttributeRefEntity
-    }); }, [getAddedAttributes, addAddedAttributes, removeAddedAttribute, updateAddedAttributeRefEntity]);
+        updateAddedAttributeRefEntity: updateAddedAttributeRefEntity,
+        resetState: resetState
+    }); }, [getAddedAttributes, addAddedAttributes, removeAddedAttribute, updateAddedAttributeRefEntity, resetState]);
     return React.createElement(AddedAttributesContext.Provider, { value: value }, children);
 };

package/features/workflow/contexts/ChangeRequestEditorContext/index.d.ts

@@ -27,6 +27,7 @@ export type ChangeRequestEditorContextType = {
         error: AttributeError;
         lineIds: string[];
     }[];
+    resetState: () => void;
 };
 export declare const ChangeRequestEditorContext: import("@fluentui/react-context-selector").Context<ChangeRequestEditorContextType>;
 export declare const ChangeRequestEditorProvider: ({ children }: {

package/features/workflow/contexts/ChangeRequestEditorContext/index.js

@@ -14,7 +14,8 @@ export var ChangeRequestEditorContext = createContext({
     getAllChanges: undefined,
     setErrors: undefined,
     getErrorByLineId: undefined,
-    getErrors: undefined
+    getErrors: undefined,
+    resetState: undefined
 });
 var emptyArray = [];
 var removeLineDataFromMap = function (map, lineIds) {
@@ -134,6 +135,10 @@ export var ChangeRequestEditorProvider = function (_a) {
     var getErrors = useCallback(function () {
         return errors;
     }, [errors]);
+    var resetState = useCallback(function () {
+        setLineDataMap(new Map());
+        setErrors([]);
+    }, []);
     var contextValue = {
         updateChange: updateChange,
         getLineData: getLineData,
@@ -147,7 +152,8 @@ export var ChangeRequestEditorProvider = function (_a) {
         getAllChanges: getAllChanges,
         setErrors: setErrors,
         getErrorByLineId: getErrorByLineId,
-        getErrors: getErrors
+        getErrors: getErrors,
+        resetState: resetState
     };
     return React.createElement(ChangeRequestEditorContext.Provider, { value: contextValue }, children);
 };

package/features/workflow/helpers/attributes.js

@@ -54,7 +54,7 @@ var dcrAttributesFactory = function (metadata, attributeType, attributeValue, le
     switch (attributeType.type) {
         case DataTypes.TYPE_NESTED:
         case DataTypes.TYPE_IMAGE:
-            return getNestedAttributeChange(metadata, attributeType, attributeValue, level);
+            return getNestedAttributeChange(metadata, attributeType, attributeValue, level, isReferenceSubAttribute);
         case DataTypes.TYPE_REFERENCE:
             return getReferenceAttributeChange(metadata, attributeType, attributeValue, level);
         default: {
@@ -74,14 +74,15 @@ var extractAddedId = function (attributeValue) {
     var innerChange = attributeValue.value;
     return ((_d = (_b = (_a = innerChange === null || innerChange === void 0 ? void 0 : innerChange.newValue) === null || _a === void 0 ? void 0 : _a.addedId) !== null && _b !== void 0 ? _b : (_c = attributeValue.newValue) === null || _c === void 0 ? void 0 : _c.addedId) !== null && _d !== void 0 ? _d : attributeValue.addedId);
 };
-var getNestedAttributeChange = function (metadata, attributeType, attributeValue, level) {
+var getNestedAttributeChange = function (metadata, attributeType, attributeValue, level, isReferenceSubAttribute) {
+    if (isReferenceSubAttribute === void 0) { isReferenceSubAttribute = false; }
     var attributeTypeList = getAttributeTypeSubAttributes({}, attributeType);
     var label = getLabel((attributeType === null || attributeType === void 0 ? void 0 : attributeType.label) || (attributeType === null || attributeType === void 0 ? void 0 : attributeType.name));
     var lineIds = extractLineIds(attributeValue);
     var addedId = extractAddedId(attributeValue);
     return [
-        __assign({ level: level, label: label, attributeType: attributeType, attributeValue: attributeValue, lineIds: lineIds }, (addedId && { addedId: addedId })),
-        getAttributesList(metadata, attributeTypeList, attributeValue.value, level + 1)
+        __assign(__assign({ level: level, label: label, attributeType: attributeType, attributeValue: attributeValue, lineIds: lineIds }, (isReferenceSubAttribute && { isReferenceSubAttribute: isReferenceSubAttribute })), (addedId && { addedId: addedId })),
+        getAttributesList(metadata, attributeTypeList, attributeValue.value, level + 1, isReferenceSubAttribute)
     ];
 };
 var getReferenceAttributeChange = function (metadata, attributeType, attributeValue, level) {

package/features/workflow/helpers/attributes.test.js

@@ -123,6 +123,61 @@ describe('attributes helpers tests', function () {
             }
         ]);
     });
+    it('should mark a nested attribute and its sub-attributes inside a reference attribute as isReferenceSubAttribute=true', function () {
+        var metadata = getMetadata();
+        var objectInfo = {
+            isExist: true,
+            label: 'HCA',
+            secondaryLabel: '',
+            type: 'configuration/entityTypes/HCA',
+            uri: 'entities/1hRTSKE5'
+        };
+        var changes = {
+            Address: [
+                {
+                    value: {
+                        AdditionalAttributes: [
+                            {
+                                value: {
+                                    AttributeType: [
+                                        {
+                                            value: {
+                                                newValue: { value: 'TypeA' },
+                                                type: DCRTypes.INSERT_ATTRIBUTE
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        ]
+                    }
+                }
+            ]
+        };
+        expect(getEntityChanges(metadata, objectInfo, changes)).toEqual([
+            {
+                attributeType: metadata.entityTypes[0].attributes[4],
+                attributeValue: changes.Address[0],
+                label: 'Address',
+                level: 0
+            },
+            {
+                attributeType: metadata.relationTypes[0].attributes[0],
+                attributeValue: changes.Address[0].value.AdditionalAttributes[0],
+                label: 'Additional Attributes',
+                level: 1,
+                isReferenceSubAttribute: true
+            },
+            {
+                attributeType: metadata.relationTypes[0].attributes[0].attributes[0],
+                label: 'Attribute Type',
+                level: 2,
+                newValue: changes.Address[0].value.AdditionalAttributes[0].value.AttributeType[0].value.newValue,
+                operation: DCROperationTypes.ADDED,
+                isReferenceSubAttribute: true
+            }
+        ]);
+    });
     describe('getRelationsChanges behaviour', function () {
         var relationInfo = {
             endObjectLabel: '',

package/features/workflow/helpers/common.d.ts

@@ -1,4 +1,5 @@
-import { AttributeType, DCRAttributeValue, DCRObjectsInfo, DCROperationTypes, DCRValue, Metadata, WorkflowDefinition, WorkflowTaskData } from '@reltio/mdm-sdk';
+import { AttributeType, DCRAttributeValue, DCRObjectsInfo, DCROperationTypes, DCRValue, Metadata, PrimitiveValue, WorkflowDefinition, WorkflowTaskData } from '@reltio/mdm-sdk';
+export declare const isPrimitiveValue: (value: unknown) => value is PrimitiveValue;
 export declare const getOperationType: (type: string, newPinOrIgnoreValue?: boolean) => DCROperationTypes;
 export declare const getOperationLabel: (operation: DCROperationTypes) => string;
 export declare const getAttributeDescription: (attrType: AttributeType, value: DCRAttributeValue, currentEntityUri: string, objectsInfo?: DCRObjectsInfo) => {

package/features/workflow/helpers/common.js

@@ -1,6 +1,9 @@
 import { allPass, always, equals, evolve, filter, has, identity, isNil, length, nth, pipe, prop, propEq, split, startsWith, unless, when } from 'ramda';
 import i18n from 'ui-i18n';
 import { DataTypes, DCROperationTypes, DCRTypes, EntityAttrTypes, getAttrDataTypeDefinition, getRoleLabel, isUrl } from '@reltio/mdm-sdk';
+export var isPrimitiveValue = function (value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+};
 export var getOperationType = function (type, newPinOrIgnoreValue) {
     switch (type) {
         case DCRTypes.CREATE_RELATIONSHIP:

package/features/workflow/helpers/dcr.js

@@ -21,6 +21,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import { createEntryDeleteAttribute, DCRTypes, EventType, findAttributeTypeByUri, getReferencedEntityTypeUriFromAttrType, isEmptyValue, isEntityUri, isNested, isRelationTypeUri, isRelationUri } from '@reltio/mdm-sdk';
 import { allPass, append, assocPath, concat, curry, dissocPath, equals, filter, flatten, fromPairs, groupBy, has, hasPath, isEmpty, isNil, keys, map, partition, path, pathOr, pipe, pluck, prop, propOr, toPairs, values, uniq, uniqBy, when } from 'ramda';
 import { ADDED_CHANGE_ID_PREFIX } from '../contexts/AddedAttributesContext';
+import { isPrimitiveValue } from './common';
 var isAddedChange = function (changeId) { return changeId === null || changeId === void 0 ? void 0 : changeId.startsWith(ADDED_CHANGE_ID_PREFIX); };
 var normalizeReferenceValueForApi = function (val, change, metadata) {
     var attrType = findAttributeTypeByUri(metadata, change.attributeType);
@@ -101,7 +102,7 @@ export var isCreateEntityOperation = function (dcr) {
     return dcr.type === DCRTypes.CREATE_ENTITY;
 };
 var cleanValueRecursively = function (value) {
-    if (isNil(value) || typeof value === 'string' || isEmpty(value)) {
+    if (isNil(value) || isPrimitiveValue(value) || isEmpty(value)) {
         return value;
     }
     var cleanedProperties = map(function (propertyValues) {

package/features/workflow/helpers/dcr.test.js

@@ -280,6 +280,53 @@ describe('dcr helpers tests', function () {
                     ]
                 } }));
         });
+        it('should preserve primitive boolean defaultValue for added attribute when no lineData exists', function () {
+            var changes = {
+                'entities/456': [
+                    {
+                        id: 'added|bool1',
+                        type: DCRTypes.INSERT_ATTRIBUTE,
+                        attributePath: 'PrimaryAffiliationIndicator',
+                        attributeType: 'configuration/entityTypes/HCP/attributes/PrimaryAffiliationIndicator',
+                        newValue: { value: false }
+                    }
+                ]
+            };
+            var result = buildDCRSavePlan(changes, noLineData, emptyMetadata);
+            expect(result).toEqual(__assign(__assign({}, emptyPlan), { insertEntityAttributes: {
+                    'entities/456': [
+                        {
+                            type: 'INSERT_ATTRIBUTE',
+                            uri: 'entities/456/attributes/PrimaryAffiliationIndicator',
+                            newValue: [{ value: false }]
+                        }
+                    ]
+                } }));
+        });
+        it('should send user-edited boolean value for added attribute', function () {
+            var changes = {
+                'entities/456': [
+                    {
+                        id: 'added|bool2',
+                        type: DCRTypes.INSERT_ATTRIBUTE,
+                        attributePath: 'PrimaryAffiliationIndicator',
+                        attributeType: 'configuration/entityTypes/HCP/attributes/PrimaryAffiliationIndicator',
+                        newValue: { value: false }
+                    }
+                ]
+            };
+            var lineData = [['456/added|bool2/newValue', { value: { value: 'true' } }]];
+            var result = buildDCRSavePlan(changes, function (changeId) { return (changeId === 'added|bool2' ? lineData : []); }, emptyMetadata);
+            expect(result).toEqual(__assign(__assign({}, emptyPlan), { insertEntityAttributes: {
+                    'entities/456': [
+                        {
+                            type: 'INSERT_ATTRIBUTE',
+                            uri: 'entities/456/attributes/PrimaryAffiliationIndicator',
+                            newValue: [{ value: 'true' }]
+                        }
+                    ]
+                } }));
+        });
         it('should preserve lookup sub-attribute with lookupCode inside nested parent', function () {
             var metadata = {
                 entityTypes: [

package/features/workflow/helpers/merge.js

@@ -10,7 +10,7 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { both, concat, curry, difference, flatten, isNil, omit, path, pathEq, pick, pipe, propEq, propOr, reduce } from 'ramda';
-import { DCRTypes, EntityAttrTypes, generateTempUri, getRoleLabel, isEmptyValue } from '@reltio/mdm-sdk';
+import { DCRTypes, EntityAttrTypes, generateTempUri, isEmptyValue } from '@reltio/mdm-sdk';
 import { getEntityChanges, getRelationChanges } from './attributes';
 var ATTRIBUTE_DELIMITER = '/';
 var SPECIAL_ATTRIBUTES_NAMES = [
@@ -166,7 +166,7 @@ var createEntityOrRelation = function (metadata, value) {
         newObject[EntityAttrTypes.roles.name] = [
             {
                 type: DCRTypes.INSERT_ATTRIBUTE,
-                newValue: __assign({ value: addedId ? [] : roles.map(getRoleLabel(metadata)), lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.roles.name)] }, (addedId && { addedId: addedId }))
+                newValue: __assign({ value: addedId ? [] : roles, lineIds: lineIds && ["".concat(lineIds[0], "/").concat(EntityAttrTypes.roles.name)] }, (addedId && { addedId: addedId }))
             }
         ];
     }

package/features/workflow/helpers/merge.test.js

@@ -389,4 +389,38 @@ describe('mergeChanges tests', function () {
         var mergedChanges = mergeChanges(metadata, changes, objectInfo, [])[0];
         expect((_c = (_b = mergedChanges[0]) === null || _b === void 0 ? void 0 : _b.newValue) === null || _c === void 0 ? void 0 : _c.lineIds).toEqual(['line-2', 'line-4']);
     });
+    it('should keep role URIs in CREATE_ENTITY changes without mapping to labels', function () {
+        var _a;
+        var _b;
+        var metadata = getMetadata();
+        var roleUris = [
+            'configuration/roles/DirectorofNursing',
+            'configuration/roles/MedicalAssistant',
+            'configuration/roles/LabDirectors'
+        ];
+        var changes = (_a = {},
+            _a[entityUri] = [
+                {
+                    id: 'create1',
+                    type: DCRTypes.CREATE_ENTITY,
+                    objectType: 'configuration/entityTypes/HCA',
+                    newValue: {
+                        uri: entityUri,
+                        type: 'configuration/entityTypes/HCA',
+                        attributes: {
+                            ActivationDate: [{ value: '2024-01-01' }]
+                        },
+                        roles: roleUris,
+                        crosswalks: [{ type: 'configuration/sources/Reltio', value: '1hRTSKE5', dataProvider: true }],
+                        analyticsAttributes: {}
+                    }
+                }
+            ],
+            _a);
+        var entityChanges = mergeChanges(metadata, changes, objectInfo, [])[0];
+        var rolesDiff = entityChanges.find(function (d) { var _a; return ((_a = d.attributeType) === null || _a === void 0 ? void 0 : _a.uri) === EntityAttrTypes.roles.uri; });
+        expect(rolesDiff).toBeDefined();
+        var rolesNewValue = (_b = rolesDiff.newValue) === null || _b === void 0 ? void 0 : _b.value;
+        expect(rolesNewValue).toEqual(roleUris);
+    });
 });

package/features/workflow/helpers/metadata.test-data.js

@@ -261,5 +261,14 @@ export var getMetadata = function () { return ({
                 }
             ]
         }
+    ],
+    roles: [
+        {
+            uri: 'configuration/roles/DirectorofNursing',
+            label: 'Director of Nursing',
+            description: 'Director of Nursing'
+        },
+        { uri: 'configuration/roles/MedicalAssistant', label: 'Medical Assistant', description: 'Medical Assistant' },
+        { uri: 'configuration/roles/LabDirectors', label: 'Lab Directors', description: 'Lab Directors' }
     ]
 }); };

package/features/workflow/helpers/validation.js

@@ -21,6 +21,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import { clone } from 'ramda';
 import i18n from 'ui-i18n';
 import { findAttributeTypeByUri, DCRTypes, getRequiredAttributeTypesByTypeUri, buildError, ErrorType, getParentUri, findAttributeValuesByTypeUri, isEmptyValue, isOv, isIgnored, ErrorSource, evaluateErrorPath, isReference } from '@reltio/mdm-sdk';
+import { isPrimitiveValue } from './common';
 var ALLOWED_CHANGE_TYPES = [
     DCRTypes.UPDATE_ATTRIBUTE,
     DCRTypes.INSERT_ATTRIBUTE,
@@ -256,7 +257,7 @@ var validateRequiredComplexAttributes = function (_a) {
         return [];
     }
     var valueHolder = change.type === DCRTypes.CREATE_ENTITY || change.type === DCRTypes.CREATE_RELATIONSHIP ? 'attributes' : 'value';
-    var rootAttributeTypeUri = change.refAttributeType || change.attributeType || change.objectType;
+    var rootAttributeTypeUri = change.attributeType || change.refAttributeType || change.objectType;
     if (!rootAttributeTypeUri) {
         return [];
     }
@@ -286,7 +287,7 @@ var validateRequiredComplexAttributes = function (_a) {
         var errors = [];
         var visitValue = function (value, path) {
             var isRejected = checkIsChangeRejected(path.slice(0, -1).join('/'));
-            if (typeof value === 'string') {
+            if (isPrimitiveValue(value)) {
                 return !isRejected;
             }
             if (isRejected) {

package/features/workflow/helpers/validation.test-data.d.ts

@@ -10,5 +10,6 @@ export declare const getUserChanges: () => UserChange[];
 export declare const getUserChangesRejectSubnestedAttributes: () => UserChange[];
 export declare const getUserChangesRejectSubnestedRelationAttributes: () => UserChange[];
 export declare const getUserChangesSubnestedEmpty: () => UserChange[];
+export declare const getChangesWithBooleanPrimitiveValue: () => DCRChanges;
 export declare const getUserChangesNewEntity: () => UserChange[];
 export {};

package/features/workflow/helpers/validation.test-data.js

@@ -478,6 +478,38 @@ export var getUserChangesSubnestedEmpty = function () { return [
         }
     }
 ]; };
+export var getChangesWithBooleanPrimitiveValue = function () { return ({
+    'entities/entityUri1': [
+        {
+            id: '0SBn7Oa',
+            type: DCRTypes.INSERT_ATTRIBUTE,
+            createdTime: 1761922840650,
+            createdBy: 'ivan.kositsin',
+            objectType: 'configuration/entityTypes/HCP',
+            attributePath: 'Specialities',
+            newValue: {
+                value: {
+                    SpecialityStatus: [
+                        {
+                            value: 'ACTIVE'
+                        }
+                    ],
+                    PrimarySpecialityInd: [
+                        {
+                            value: false
+                        }
+                    ]
+                }
+            },
+            crosswalk: {
+                type: 'configuration/sources/Reltio',
+                value: 'entityUri1'
+            },
+            newPinOrIgnoreValue: false,
+            attributeType: 'configuration/entityTypes/HCP/attributes/Specialities'
+        }
+    ]
+}); };
 export var getUserChangesNewEntity = function () { return [
     {
         lineId: 'entityUri2/0IEiwoe/newValue/attributes/Name/0',

package/features/workflow/helpers/validation.test.js

@@ -1,6 +1,6 @@
 import { getValidationErrors } from './validation';
 import { getMetadata } from './metadata.test-data';
-import { getChanges, getEntitiesOrRelations, getUserChanges, getUserChangesRejectSubnestedAttributes, getUserChangesRejectSubnestedRelationAttributes, getUserChangesSubnestedEmpty, getUserChangesNewEntity } from './validation.test-data';
+import { getChanges, getChangesWithBooleanPrimitiveValue, getEntitiesOrRelations, getUserChanges, getUserChangesRejectSubnestedAttributes, getUserChangesRejectSubnestedRelationAttributes, getUserChangesSubnestedEmpty, getUserChangesNewEntity } from './validation.test-data';
 import { findAttributeTypeByUri } from '@reltio/mdm-sdk';
 describe('getValidationErrors', function () {
     it('should validate required attributes with user changes', function () {
@@ -213,6 +213,16 @@ describe('getValidationErrors', function () {
             }
         ]);
     });
+    it('should not report a missing required boolean attribute when its value is primitive false', function () {
+        var metadata = getMetadata();
+        var result = getValidationErrors({
+            changes: getChangesWithBooleanPrimitiveValue(),
+            userChanges: [],
+            entitiesOrRelations: getEntitiesOrRelations(),
+            metadata: metadata
+        });
+        expect(result).toEqual([]);
+    });
     it('should validate required attributes in new entity', function () {
         var metadata = getMetadata();
         var result = getValidationErrors({

package/features/workflow/hooks/useChangeRequest.d.ts

@@ -2,4 +2,5 @@ import { ChangeRequest, GroupedObjectsInfo } from '@reltio/mdm-sdk';
 export declare const useChangeRequest: (dcrUri: string) => {
     dcr: ChangeRequest;
     groupedObjects: GroupedObjectsInfo[];
+    reloadDcr: () => void;
 };

package/features/workflow/hooks/useChangeRequest.js

@@ -25,8 +25,8 @@ export var useChangeRequest = function (dcrUri) {
         }
         return safePromise(getEntitiesByUris(entityUris, { searchOptions: 'ovOnly', defaultMaxValues: 1 }));
     }, []); // eslint-disable-line
-    useEffect(function () {
-        getDataChangeRequest(dcrUri)
+    var loadDcr = useCallback(function () {
+        safePromise(getDataChangeRequest(dcrUri))
             .then(function (dcr) {
             var changes = dcr.changes, objectsInfo = dcr.objectsInfo;
             var objectsWithChanges = extractObjectsFromChangeRequest(changes, objectsInfo);
@@ -37,7 +37,7 @@ export var useChangeRequest = function (dcrUri) {
             requestEntities(entityUris)
                 .then(function (entities) {
                 var relationsObjectsWithRequestedEntities = relationsObjectsWithoutEntity.map(function (relationsObject, index) {
-                    return __assign(__assign({}, relationsObject), { entity: entities[index] });
+                    return __assign(__assign({}, relationsObject), { entity: __assign(__assign({}, entities[index]), { isExist: true }) });
                 });
                 pipe(flatten, reduce(concatEntityRelationsObjects, {}), values, setGroupedObjects)([
                     entityObjectsWithRelations,
@@ -49,6 +49,9 @@ export var useChangeRequest = function (dcrUri) {
             setDcr(dcr);
         })
             .catch(showErrorMessage);
-    }, [dcrUri, requestEntities]);
-    return { dcr: dcr, groupedObjects: groupedObjects };
+    }, [dcrUri, requestEntities, safePromise]);
+    useEffect(function () {
+        loadDcr();
+    }, [loadDcr]);
+    return { dcr: dcr, groupedObjects: groupedObjects, reloadDcr: loadDcr };
 };

package/features/workflow/hooks/useChangeRequest.test.js

@@ -127,7 +127,8 @@ describe('useChangeRequest tests', function () {
         expect(getEntitiesByUris).not.toHaveBeenCalled();
         expect(result.current).toEqual({
             dcr: null,
-            groupedObjects: []
+            groupedObjects: [],
+            reloadDcr: expect.any(Function)
         });
     });
     it('should return empty parameters if dcrUri is undefined', function () {
@@ -136,7 +137,8 @@ describe('useChangeRequest tests', function () {
         expect(getEntitiesByUris).not.toHaveBeenCalled();
         expect(result.current).toEqual({
             dcr: null,
-            groupedObjects: []
+            groupedObjects: [],
+            reloadDcr: expect.any(Function)
         });
     });
     it('should go to error message in case of getDataChangeRequest error', function () { return __awaiter(void 0, void 0, void 0, function () {
@@ -159,7 +161,8 @@ describe('useChangeRequest tests', function () {
                     });
                     expect(result.current).toEqual({
                         dcr: null,
-                        groupedObjects: []
+                        groupedObjects: [],
+                        reloadDcr: expect.any(Function)
                     });
                     return [2 /*return*/];
             }
@@ -198,7 +201,8 @@ describe('useChangeRequest tests', function () {
                     });
                     expect(result.current).toEqual({
                         dcr: dcr,
-                        groupedObjects: []
+                        groupedObjects: [],
+                        reloadDcr: expect.any(Function)
                     });
                     return [2 /*return*/];
             }
@@ -234,6 +238,7 @@ describe('useChangeRequest tests', function () {
                     expect(ErrorPopup.addError).not.toHaveBeenCalled();
                     expect(result.current).toEqual({
                         dcr: dcr,
+                        reloadDcr: expect.any(Function),
                         groupedObjects: [
                             {
                                 entity: {
@@ -267,7 +272,8 @@ describe('useChangeRequest tests', function () {
                             },
                             {
                                 entity: {
-                                    uri: 'entities/151gdPs5'
+                                    uri: 'entities/151gdPs5',
+                                    isExist: true
                                 },
                                 relations: [
                                     {

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

@@ -4,9 +4,10 @@ type Task = Partial<Pick<WorkflowTaskData, 'taskId' | 'possibleActions' | 'assig
 type Props = {
     task: Task;
     onActionSuccess?: (action: string) => void;
+    onError?: () => void;
     beforeAction?: () => Promise<BeforeActionOutcome>;
 };
-export declare const useWorkflowActions: ({ task, onActionSuccess, beforeAction }: Props) => {
+export declare const useWorkflowActions: ({ task, onActionSuccess, onError, beforeAction }: Props) => {
     actions: TaskAction[];
     actionRequestIsInProgress: boolean;
 };