@reltio/components 1.4.2260 → 1.4.2262

package/features/activity-log/utils/activities.js

@@ -9,7 +9,7 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { formatDataTypeValue, findAttributeTypeByUri, makeAttrTypeUri, getAttrDataTypeDefinition } from '@reltio/mdm-sdk';
+import { formatDataTypeValue, findAttributeTypeByUri, makeAttrTypeUri, getAttrDataTypeDefinition, shouldDisableTimestampLocalizationForAttribute } from '@reltio/mdm-sdk';
 import { filter, groupBy, ifElse, map, path, pipe, propOr, values, isNil, includes, reject } from 'ramda';
 import i18n from 'ui-i18n';
 import { ActivityTypes } from '../types';
@@ -35,10 +35,15 @@ export var splitActivityByType = function (activity) {
         return length > 1;
     }, map(function (items) { return (__assign(__assign({}, activity), { items: items, itemsTotal: items.length })); }), function () { return [activity]; }))(activity);
 };
-export var stringifyDeltaValue = function (deltaValue, attributeTypeUri, metadata, attributesPresentation) {
+export var stringifyDeltaValue = function (deltaValue, attributeTypeUri, metadata, attributesPresentation, options) {
+    if (options === void 0) { options = {}; }
     var attributeType = findAttributeTypeByUri(metadata, attributeTypeUri);
     var dataTypeDefinition = getAttrDataTypeDefinition(attributeType);
-    var formatValue = formatDataTypeValue({ attributesPresentation: attributesPresentation, dataTypeDefinition: dataTypeDefinition });
+    var formatValue = formatDataTypeValue({
+        attributesPresentation: attributesPresentation,
+        dataTypeDefinition: dataTypeDefinition,
+        disableTimestampLocalization: shouldDisableTimestampLocalizationForAttribute(attributeType, options)
+    });
     if (isNil(deltaValue)) {
         return '';
     }
@@ -49,7 +54,7 @@ export var stringifyDeltaValue = function (deltaValue, attributeTypeUri, metadat
         .flatMap(function (_a) {
         var attributeTypeName = _a[0], deltaValues = _a[1];
         return deltaValues.map(function (deltaValue) {
-            return stringifyDeltaValue(deltaValue.value, makeAttrTypeUri(attributeTypeUri, attributeTypeName), metadata, attributesPresentation);
+            return stringifyDeltaValue(deltaValue.value, makeAttrTypeUri(attributeTypeUri, attributeTypeName), metadata, attributesPresentation, options);
         });
     })
         .join(', ');

package/features/activity-log/utils/activities.test.js

@@ -11,8 +11,14 @@ var __assign = (this && this.__assign) || function () {
 };
 import i18n from 'ui-i18n';
 import { identity } from 'ramda';
+import { formatDataTypeValue } from '@reltio/mdm-sdk';
 import { ActivityTypes } from '../types';
 import { getActivityType, isValidActivityType, removeIgnoredItems, splitActivityByType, stringifyDeltaValue } from './activities';
+jest.mock('@reltio/mdm-sdk', function () {
+    var actual = jest.requireActual('@reltio/mdm-sdk');
+    return __assign(__assign({}, actual), { formatDataTypeValue: jest.fn(actual.formatDataTypeValue) });
+});
+var formatDataTypeValueMock = formatDataTypeValue;
 describe('activities utils tests', function () {
     var activityWithDataTypes = {
         uri: 'activities/711d84f6-f96b-4b93-b06f-a165c1776914',
@@ -369,6 +375,7 @@ describe('activities utils tests', function () {
         });
         afterEach(function () {
             i18nDateSpy.mockReset();
+            formatDataTypeValueMock.mockClear();
         });
         var metadata = {
             entityTypes: [
@@ -545,6 +552,20 @@ describe('activities utils tests', function () {
                 ]
             }, attributeTypeUri, metadata)).toBe('2022-12-02, 12,345, String 2, $5,000, String, Yes, 2020-12-01T15:12:00.000+0000');
         });
+        describe('disableTimestampLocalization', function () {
+            var middleOfUtcDayMs = Date.UTC(2019, 10, 1, 14, 30, 0);
+            var regularTimestampUri = 'configuration/entityTypes/HCP/attributes/Timestamp';
+            it('forwards disableTimestampLocalization=true to formatDataTypeValue for regular Timestamp', function () {
+                stringifyDeltaValue(String(middleOfUtcDayMs), regularTimestampUri, metadata, undefined, {
+                    disableTimestampLocalization: true
+                });
+                expect(formatDataTypeValueMock).toHaveBeenCalledWith(expect.objectContaining({ disableTimestampLocalization: true }));
+            });
+            it('forwards disableTimestampLocalization=false for regular Timestamp when option is missing', function () {
+                stringifyDeltaValue(String(middleOfUtcDayMs), regularTimestampUri, metadata);
+                expect(formatDataTypeValueMock).toHaveBeenCalledWith(expect.objectContaining({ disableTimestampLocalization: false }));
+            });
+        });
     });
     describe('removeIgnoredItems', function () {
         var consoleWarnMock;

package/features/workflow/ChangeRequestEditor/components/DCRValueEditor/DCRValueEditor.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
-import { AttributeType, ChangeValue, PrimitiveValue, SimpleAttributeValue } from '@reltio/mdm-sdk';
+import { AttributeType, ChangeValue, LookupValue, PrimitiveValue, SimpleAttributeValue } from '@reltio/mdm-sdk';
 import { LineDataValue } from '../../../types';
 type Props = {
     attributeType: AttributeType;
     value: LineDataValue | ChangeValue;
-    onChange: (value: SimpleAttributeValue | string[] | PrimitiveValue) => void;
+    onChange: (value: SimpleAttributeValue | string[] | PrimitiveValue | LookupValue) => void;
     disabled?: boolean;
 };
 export declare const DCRValueEditor: ({ attributeType, value, onChange, disabled }: Props) => React.JSX.Element;

package/features/workflow/ChangeRequestEditor/components/DCRValueEditor/DCRValueEditor.js

@@ -1,12 +1,19 @@
 import React from 'react';
+import { shouldDisableTimestampLocalizationForAttribute } from '@reltio/mdm-sdk';
 import { DCRValueEditorFactory } from '../DCRValueEditorFactory';
+import { useMdmDisableTimestampLocalization } from '../../../../../contexts/MdmModuleContext';
 import styles from './DCRValueEditor.module.css';
 export var DCRValueEditor = function (_a) {
     var attributeType = _a.attributeType, value = _a.value, onChange = _a.onChange, _b = _a.disabled, disabled = _b === void 0 ? false : _b;
+    var disableTimestampLocalizationFlag = useMdmDisableTimestampLocalization();
+    var disableTimestampLocalization = shouldDisableTimestampLocalizationForAttribute(attributeType, {
+        disableTimestampLocalization: disableTimestampLocalizationFlag
+    });
     return (React.createElement("div", { className: styles.editor }, DCRValueEditorFactory.build({
         attributeType: attributeType,
         value: value,
         onChange: onChange,
-        disabled: disabled
+        disabled: disabled,
+        disableTimestampLocalization: disableTimestampLocalization
     })));
 };

package/features/workflow/ChangeRequestEditor/components/DCRValueEditorFactory/DCRValueEditorFactory.d.ts

@@ -1,14 +1,14 @@
 import React from 'react';
-import { type AttributeType, type ChangeValue, type DataTypeDefinition, type PrimitiveValue, type SimpleAttributeValue } from '@reltio/mdm-sdk';
+import { type AttributeType, type ChangeValue, type LookupValue, type PrimitiveValue, type SimpleAttributeValue } from '@reltio/mdm-sdk';
 import type { LineDataValue } from '../../../types';
 type Props = {
     attributeType: AttributeType;
     value: LineDataValue | ChangeValue;
-    onChange: (value: SimpleAttributeValue | string[] | PrimitiveValue) => void;
-    dataTypeDefinition?: DataTypeDefinition;
+    onChange: (value: SimpleAttributeValue | string[] | PrimitiveValue | LookupValue) => void;
     disabled?: boolean;
+    disableTimestampLocalization?: boolean;
 };
 export declare class DCRValueEditorFactory {
-    static build({ attributeType, value, onChange, disabled }: Props): React.JSX.Element;
+    static build({ attributeType, value, onChange, disabled, disableTimestampLocalization }: Props): React.JSX.Element;
 }
 export {};

package/features/workflow/ChangeRequestEditor/components/DCRValueEditorFactory/DCRValueEditorFactory.js

@@ -10,7 +10,7 @@ var DCRValueEditorFactory = /** @class */ (function () {
     function DCRValueEditorFactory() {
     }
     DCRValueEditorFactory.build = function (_a) {
-        var attributeType = _a.attributeType, value = _a.value, onChange = _a.onChange, _b = _a.disabled, disabled = _b === void 0 ? false : _b;
+        var attributeType = _a.attributeType, value = _a.value, onChange = _a.onChange, _b = _a.disabled, disabled = _b === void 0 ? false : _b, _c = _a.disableTimestampLocalization, disableTimestampLocalization = _c === void 0 ? false : _c;
         var dcrValue = getAttributeValue(value);
         switch (attributeType.uri) {
             case EntityAttrTypes.roles.uri: {
@@ -25,10 +25,14 @@ var DCRValueEditorFactory = /** @class */ (function () {
             default: {
                 var dataTypeDefinition = getDataTypeDefinition(attributeType, dcrValue);
                 var editorValue = value && dataTypeDefinition
-                    ? attributeValueToEditorValue(value, dataTypeDefinition)
+                    ? attributeValueToEditorValue(value, dataTypeDefinition, {
+                        disableTimestampLocalization: disableTimestampLocalization
+                    })
                     : null;
-                var handleChange = function (value) {
-                    var valueConvertedToAttributeValue = editorValueToAttributeValue(attributeType, value);
+                var handleChange = function (newValue) {
+                    var valueConvertedToAttributeValue = editorValueToAttributeValue(attributeType, newValue, {
+                        disableTimestampLocalization: disableTimestampLocalization
+                    });
                     onChange(valueConvertedToAttributeValue);
                 };
                 return (React.createElement(DataTypeValueEditor, { fieldName: attributeType.uri, value: editorValue, dataTypeDefinition: dataTypeDefinition, onChange: handleChange, fullWidth: true, disabled: disabled }));

package/helpers/attributesView.d.ts

@@ -1,4 +1,4 @@
-import { AttributeType, DataTypeDefinition, Metadata, NestedAttributeValue, ReferenceAttributeValue, SimpleAttributeValue } from '@reltio/mdm-sdk';
+import { AttributeType, DataTypeDefinition, LookupValue, Metadata, NestedAttributeValue, PrimitiveValue, ReferenceAttributeValue, SimpleAttributeValue } from '@reltio/mdm-sdk';
 import { AttributeSelectorItem } from '../types';
 export declare const getFilteredAttrTypes: (metadata: Metadata, type: string, includeUris: string[], excludeUris: string[]) => any;
 type PagersData = {
@@ -6,11 +6,12 @@ type PagersData = {
     values: (SimpleAttributeValue | NestedAttributeValue | ReferenceAttributeValue | string | number)[];
 };
 export declare const splitPagersData: (fixedTypeUris: string[], pagersData: PagersData[]) => [PagersData[], PagersData[]];
-export declare const attributeValueToEditorValue: (attributeValue: SimpleAttributeValue, { type }: DataTypeDefinition) => string | number | boolean | Date | {
-    value: import("@reltio/mdm-sdk").PrimitiveValue;
-    lookupCode: string;
+export type AttributeValueConversionOptions = {
+    disableTimestampLocalization?: boolean;
 };
-export declare const editorValueToAttributeValue: (attributeType: any, editorValue: any) => any;
+export type EditorValue = PrimitiveValue | Date | LookupValue | null;
+export declare const attributeValueToEditorValue: (attributeValue: SimpleAttributeValue, { type }: DataTypeDefinition, { disableTimestampLocalization }?: AttributeValueConversionOptions) => EditorValue;
+export declare const editorValueToAttributeValue: (attributeType: AttributeType, editorValue: EditorValue, { disableTimestampLocalization }?: AttributeValueConversionOptions) => PrimitiveValue | LookupValue;
 export declare const isEqualAttributes: any;
 export declare const checkAttributeIncludes: (attribute: AttributeSelectorItem, selectedAttributes: AttributeSelectorItem[]) => boolean;
 export {};

package/helpers/attributesView.js

@@ -16,9 +16,10 @@ export var getFilteredAttrTypes = function (metadata, type, includeUris, exclude
 export var splitPagersData = function (fixedTypeUris, pagersData) {
     return partition(pipe(path(['attrType', 'uri']), includes(__, fixedTypeUris)), pagersData);
 };
-export var attributeValueToEditorValue = function (attributeValue, _a) {
+export var attributeValueToEditorValue = function (attributeValue, _a, _b) {
     var type = _a.type;
-    var _b = attributeValue || {}, value = _b.value, lookupCode = _b.lookupCode;
+    var _c = _b === void 0 ? {} : _b, _d = _c.disableTimestampLocalization, disableTimestampLocalization = _d === void 0 ? false : _d;
+    var _e = attributeValue || {}, value = _e.value, lookupCode = _e.lookupCode;
     switch (type) {
         case DataTypes.TYPE_BOOLEAN:
         case DataTypes.TYPE_BOOLEAN_RADIO:
@@ -27,8 +28,16 @@ export var attributeValueToEditorValue = function (attributeValue, _a) {
         }
         case DataTypes.TYPE_DATE:
             return (value && utils.dates.toLocalDate(value)) || null;
+        case DataTypes.TYPE_TIMESTAMP: {
+            if (!value) {
+                return null;
+            }
+            if (disableTimestampLocalization) {
+                return utils.dates.toLocalDate(value);
+            }
+            return new Date(value);
+        }
         case DataTypes.TYPE_LOCAL_DATE:
-        case DataTypes.TYPE_TIMESTAMP:
         case DataTypes.TYPE_ACTIVENESS_DATE: {
             return (value && new Date(value)) || null;
         }
@@ -40,7 +49,8 @@ export var attributeValueToEditorValue = function (attributeValue, _a) {
             return value;
     }
 };
-export var editorValueToAttributeValue = function (attributeType, editorValue) {
+export var editorValueToAttributeValue = function (attributeType, editorValue, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.disableTimestampLocalization, disableTimestampLocalization = _c === void 0 ? false : _c;
     var type = getAttrDataTypeDefinition(attributeType).type;
     switch (type) {
         case DataTypes.TYPE_BOOLEAN:
@@ -50,17 +60,21 @@ export var editorValueToAttributeValue = function (attributeType, editorValue) {
         case DataTypes.TYPE_DATE:
             return (editorValue && moment(editorValue).format('YYYY-MM-DD')) || '';
         case DataTypes.TYPE_TIMESTAMP: {
-            return ((editorValue &&
-                moment(editorValue)
-                    .utc()
-                    .format()) ||
-                '');
+            if (!editorValue) {
+                return '';
+            }
+            if (disableTimestampLocalization) {
+                return moment.utc(utils.dates.toUtcDate(editorValue)).format();
+            }
+            return moment(editorValue)
+                .utc()
+                .format();
         }
         case DataTypes.TYPE_ACTIVENESS_DATE:
         case DataTypes.TYPE_LOCAL_DATE:
             return editorValue && editorValue.valueOf();
         default:
-            return editorValue || '';
+            return (editorValue || '');
     }
 };
 export var isEqualAttributes = eqBy(pick(['fieldName', 'uri', 'entityTypeUri']));

package/helpers/attributesView.test.js

@@ -1,5 +1,5 @@
 import { DataTypes } from '@reltio/mdm-sdk';
-import { attributeValueToEditorValue } from './attributesView';
+import { attributeValueToEditorValue, editorValueToAttributeValue } from './attributesView';
 describe('attributesView tests', function () {
     describe('attributeValueToEditorValue', function () {
         it('should return true if attribute is boolean and value is string', function () {
@@ -73,6 +73,48 @@ describe('attributesView tests', function () {
             };
             expect(attributeValueToEditorValue(attributeValue, attributeType)).toBe(null);
         });
+        describe('TYPE_TIMESTAMP', function () {
+            var attributeType = {
+                type: DataTypes.TYPE_TIMESTAMP,
+                uri: 'configuration/entityTypes/HCP/attributes/Updated',
+                name: 'Updated'
+            };
+            it('returns Date constructed from value when flag is off', function () {
+                var ms = Date.UTC(2020, 1, 20, 7, 0, 0);
+                var result = attributeValueToEditorValue({ value: ms, uri: '' }, attributeType);
+                expect(result).toEqual(new Date(ms));
+            });
+            it('uses toLocalDate (UTC parts as local) when flag is on (numeric input)', function () {
+                var ms = Date.UTC(2020, 1, 20, 7, 15, 30);
+                var result = attributeValueToEditorValue({ value: ms, uri: '' }, attributeType, {
+                    disableTimestampLocalization: true
+                });
+                expect(result.getFullYear()).toBe(2020);
+                expect(result.getMonth()).toBe(1);
+                expect(result.getDate()).toBe(20);
+                expect(result.getHours()).toBe(7);
+                expect(result.getMinutes()).toBe(15);
+                expect(result.getSeconds()).toBe(30);
+            });
+            it('uses toLocalDate when flag is on (ISO string input)', function () {
+                var value = '2020-02-20T07:15:30.000+0000';
+                var result = attributeValueToEditorValue({ value: value, uri: '' }, attributeType, {
+                    disableTimestampLocalization: true
+                });
+                expect(result.getFullYear()).toBe(2020);
+                expect(result.getMonth()).toBe(1);
+                expect(result.getDate()).toBe(20);
+                expect(result.getHours()).toBe(7);
+                expect(result.getMinutes()).toBe(15);
+                expect(result.getSeconds()).toBe(30);
+            });
+            it('returns null when value is missing', function () {
+                expect(attributeValueToEditorValue({ value: undefined, uri: '' }, attributeType)).toBeNull();
+                expect(attributeValueToEditorValue({ value: undefined, uri: '' }, attributeType, {
+                    disableTimestampLocalization: true
+                })).toBeNull();
+            });
+        });
         it('should return lookup value+lookupCode if attribute is lookup', function () {
             var attributeValue = {
                 value: 'KT',
@@ -90,4 +132,30 @@ describe('attributesView tests', function () {
             });
         });
     });
+    describe('editorValueToAttributeValue TYPE_TIMESTAMP', function () {
+        var attributeType = {
+            type: DataTypes.TYPE_TIMESTAMP,
+            uri: 'configuration/entityTypes/HCP/attributes/Updated',
+            name: 'Updated'
+        };
+        it('returns ISO UTC string from local Date when flag is off', function () {
+            var localDate = new Date(2020, 1, 20, 7, 0, 0);
+            var result = editorValueToAttributeValue(attributeType, localDate);
+            expect(typeof result).toBe('string');
+            expect(result).toMatch(/Z$|\+00:?00$/);
+            expect(new Date(result).getTime()).toBe(localDate.getTime());
+        });
+        it('preserves local parts as UTC when flag is on', function () {
+            var localDate = new Date(2020, 1, 20, 7, 0, 0);
+            var result = editorValueToAttributeValue(attributeType, localDate, {
+                disableTimestampLocalization: true
+            });
+            var expectedMs = Date.UTC(localDate.getFullYear(), localDate.getMonth(), localDate.getDate(), localDate.getHours(), localDate.getMinutes(), localDate.getSeconds(), localDate.getMilliseconds());
+            expect(new Date(result).getTime()).toBe(expectedMs);
+        });
+        it('returns empty string when editor value is empty', function () {
+            expect(editorValueToAttributeValue(attributeType, null)).toBe('');
+            expect(editorValueToAttributeValue(attributeType, null, { disableTimestampLocalization: true })).toBe('');
+        });
+    });
 });

package/helpers/basicTable.d.ts

@@ -1,6 +1,9 @@
 import { FacetFilter } from '@reltio/mdm-sdk';
 import { ColumnData, ColumnFilter, ColumnSize } from '../types/basicTable';
 import { ColumnsSizeById } from '../types/preferences';
+export type BuildColumnsFilterOptions = {
+    disableTimestampLocalization?: boolean;
+};
 export declare const defaultGetRowCellHeight: ({ columnData, cell }: {
     columnData: any;
     cell: any;
@@ -10,6 +13,6 @@ export declare const defaultRenderRowCell: ({ cell, CellValueRenderer, ...otherP
     cell: any;
     CellValueRenderer: any;
 }) => any;
-export declare const columnFilterToMdmFilter: (columnData: Pick<ColumnData, "id" | "dataTypeDefinition">, columnFilter?: ColumnFilter) => FacetFilter;
-export declare const buildColumnsFilter: (columnsData: ColumnData[], filters?: Record<string, ColumnFilter>) => string;
+export declare const columnFilterToMdmFilter: (columnData: Pick<ColumnData, "id" | "dataTypeDefinition">, columnFilter?: ColumnFilter, { disableTimestampLocalization }?: BuildColumnsFilterOptions) => FacetFilter;
+export declare const buildColumnsFilter: (columnsData: ColumnData[], filters?: Record<string, ColumnFilter>, options?: BuildColumnsFilterOptions) => string;
 export declare const buildColumnsSizeById: (columnsSize?: ColumnSize[]) => ColumnsSizeById;

package/helpers/basicTable.js

@@ -22,7 +22,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import React from 'react';
 import { propEq, identity } from 'ramda';
-import { DataTypes, buildFilterQueryString, Maybe } from '@reltio/mdm-sdk';
+import { DataTypes, buildFilterQueryString, Maybe, shouldDisableTimestampLocalizationForAttribute } from '@reltio/mdm-sdk';
 var BLOB_HEIGHT = 100;
 var IMAGE_HEIGHT = 64;
 var PADDING = 15;
@@ -45,23 +45,23 @@ export var defaultRenderRowCell = function (_a) {
     var cell = _a.cell, CellValueRenderer = _a.CellValueRenderer, otherProps = __rest(_a, ["cell", "CellValueRenderer"]);
     return cell.values.map(function (value, index) { return React.createElement(CellValueRenderer, __assign({ key: index, value: value }, otherProps)); });
 };
-export var columnFilterToMdmFilter = function (columnData, columnFilter) {
+export var columnFilterToMdmFilter = function (columnData, columnFilter, _a) {
     if (columnFilter === void 0) { columnFilter = {}; }
-    return ({
-        fieldName: columnData.id,
-        filter: columnFilter.filter,
-        values: [columnFilter.value],
-        type: columnData.dataTypeDefinition.type
-    });
+    var _b = _a === void 0 ? {} : _a, _c = _b.disableTimestampLocalization, disableTimestampLocalization = _c === void 0 ? false : _c;
+    var dataTypeDefinition = columnData.dataTypeDefinition;
+    return __assign({ fieldName: columnData.id, filter: columnFilter.filter, values: [columnFilter.value], type: dataTypeDefinition.type }, (shouldDisableTimestampLocalizationForAttribute(dataTypeDefinition, { disableTimestampLocalization: disableTimestampLocalization })
+        ? { disableTimestampLocalization: true }
+        : {}));
 };
-export var buildColumnsFilter = function (columnsData, filters) {
+export var buildColumnsFilter = function (columnsData, filters, options) {
+    if (options === void 0) { options = {}; }
     return Maybe.fromNull(filters)
         .map(function (filters) {
         return Object.entries(filters)
             .map(function (_a) {
             var columnId = _a[0], columnFilter = _a[1];
             var columnData = columnsData.find(propEq('id', columnId));
-            return columnData && columnFilterToMdmFilter(columnData, columnFilter);
+            return columnData && columnFilterToMdmFilter(columnData, columnFilter, options);
         })
             .filter(identity);
     })

package/helpers/basicTable.test.js

@@ -1,7 +1,7 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
 import { DataTypes } from '@reltio/mdm-sdk';
-import { buildColumnsFilter, defaultRenderRowCell } from './basicTable';
+import { buildColumnsFilter, columnFilterToMdmFilter, defaultRenderRowCell } from './basicTable';
 describe('basicTable tests', function () {
     describe('defaultRenderRowCell', function () {
         it('should call CellValueRenderer with all cell values', function () {
@@ -31,5 +31,61 @@ describe('basicTable tests', function () {
         it('should return correct filter string', function () {
             expect(buildColumnsFilter(columnsData, filters)).toBe("equals(label,'123') and lte(directional,'852163199999')");
         });
+        it('should produce UTC day boundaries for Timestamp column when disableTimestampLocalization is on', function () {
+            var middleOfUtcDayMs = Date.UTC(2019, 10, 1, 14, 30, 0);
+            var utcDayStart = Date.UTC(2019, 10, 1, 0, 0, 0, 0);
+            var utcDayEnd = Date.UTC(2019, 10, 1, 23, 59, 59, 999);
+            var tsColumns = [
+                {
+                    id: 'attributes.UpdatedDate',
+                    label: 'Updated date',
+                    dataTypeDefinition: {
+                        type: DataTypes.TYPE_TIMESTAMP,
+                        uri: 'configuration/entityTypes/HCP/attributes/UpdatedDate'
+                    }
+                }
+            ];
+            var tsFilters = { 'attributes.UpdatedDate': { filter: 'on', value: middleOfUtcDayMs } };
+            expect(buildColumnsFilter(tsColumns, tsFilters, { disableTimestampLocalization: true })).toBe("range(attributes.UpdatedDate,".concat(utcDayStart, ",").concat(utcDayEnd, ")"));
+        });
+    });
+    describe('columnFilterToMdmFilter disableTimestampLocalization', function () {
+        var middleOfUtcDayMs = Date.UTC(2019, 10, 1, 14, 30, 0);
+        var regularTimestampColumn = {
+            id: 'attributes.UpdatedDate',
+            dataTypeDefinition: {
+                type: DataTypes.TYPE_TIMESTAMP,
+                uri: 'configuration/entityTypes/HCP/attributes/UpdatedDate'
+            }
+        };
+        var specialTimestampColumn = {
+            id: 'createdTime',
+            dataTypeDefinition: { type: DataTypes.TYPE_TIMESTAMP, uri: 'createdTime' }
+        };
+        var stringColumn = {
+            id: 'attributes.Name',
+            dataTypeDefinition: { type: DataTypes.TYPE_STRING, uri: 'configuration/entityTypes/HCP/attributes/Name' }
+        };
+        var onFilter = { filter: 'on', value: middleOfUtcDayMs };
+        it('adds disableTimestampLocalization to filter for regular timestamp column when flag is on', function () {
+            var result = columnFilterToMdmFilter(regularTimestampColumn, onFilter, {
+                disableTimestampLocalization: true
+            });
+            expect(result).toMatchObject({ disableTimestampLocalization: true });
+        });
+        it('does not add disableTimestampLocalization for regular timestamp column when flag is off', function () {
+            var result = columnFilterToMdmFilter(regularTimestampColumn, onFilter);
+            expect(result).not.toHaveProperty('disableTimestampLocalization');
+        });
+        it('does not add disableTimestampLocalization for special timestamp column even when flag is on', function () {
+            var result = columnFilterToMdmFilter(specialTimestampColumn, onFilter, {
+                disableTimestampLocalization: true
+            });
+            expect(result).not.toHaveProperty('disableTimestampLocalization');
+        });
+        it('does not add disableTimestampLocalization for non-timestamp column when flag is on', function () {
+            var result = columnFilterToMdmFilter(stringColumn, { filter: 'equals', value: 'John' }, { disableTimestampLocalization: true });
+            expect(result).not.toHaveProperty('disableTimestampLocalization');
+        });
     });
 });

package/hooks/useReadableSearchState/useReadableSearchState.js

@@ -1,13 +1,15 @@
 import { useEffect } from 'react';
 import { andThen, chain, pipe } from 'ramda';
 import { buildReadableQueryToString, getKeywordFromSearchState, getUnresolvedLookupsListFromSearchGroups, resolveLookupsList, getGroupsFromSearchState, buildReadableQuery } from '@reltio/mdm-sdk';
-import { useMdmAction, useMdmAttributesPresentation, useMdmDataTenants, useMdmLookups, useMdmMetadata } from '../../contexts/MdmModuleContext';
+import { useMdmAction, useMdmAttributesPresentation, useMdmDataTenants, useMdmDisableTimestampLocalization, useMdmLookups, useMdmMetadata } from '../../contexts/MdmModuleContext';
 export var useReadableSearchState = function (searchState) {
     var lookupsListResolved = useMdmAction('lookupsListResolved');
     var metadata = useMdmMetadata();
     var dataTenants = useMdmDataTenants();
     var attributesPresentation = useMdmAttributesPresentation();
     var lookups = useMdmLookups();
+    var disableTimestampLocalization = useMdmDisableTimestampLocalization();
+    var formatOptions = { disableTimestampLocalization: disableTimestampLocalization };
     var map = searchState.map;
     var keyword = getKeywordFromSearchState(searchState);
     var groups = getGroupsFromSearchState(metadata, dataTenants, true, searchState);
@@ -21,7 +23,7 @@ export var useReadableSearchState = function (searchState) {
         }
     }, [searchState]); // eslint-disable-line
     return {
-        readableQuery: buildReadableQuery(metadata, attributesPresentation, lookups, groups, keyword, map),
-        readableQueryString: buildReadableQueryToString(metadata, attributesPresentation, lookups, groups, keyword, map)
+        readableQuery: buildReadableQuery(metadata, attributesPresentation, lookups, groups, keyword, map, formatOptions),
+        readableQueryString: buildReadableQueryToString(metadata, attributesPresentation, lookups, groups, keyword, map, formatOptions)
     };
 };

package/hooks/useReadableSearchState/useReadableSearchState.test.js

@@ -108,8 +108,8 @@ describe('useReadableSearchState tests', function () {
         expect(getKeywordFromSearchState).toHaveBeenCalledWith(searchState);
         expect(getGroupsFromSearchState).toHaveBeenCalledWith(metadata, dataTenants, true, searchState);
         expect(getUnresolvedLookupsListFromSearchGroups).toHaveBeenCalledWith(groups, lookups);
-        expect(buildReadableQueryToString).toHaveBeenCalledWith(metadata, attributesPresentation, lookups, groups, keyword, map);
-        expect(buildReadableQuery).toHaveBeenCalledWith(metadata, attributesPresentation, lookups, groups, keyword, map);
+        expect(buildReadableQueryToString).toHaveBeenCalledWith(metadata, attributesPresentation, lookups, groups, keyword, map, { disableTimestampLocalization: false });
+        expect(buildReadableQuery).toHaveBeenCalledWith(metadata, attributesPresentation, lookups, groups, keyword, map, { disableTimestampLocalization: false });
         expect(resolveLookupsList).not.toHaveBeenCalled();
         expect(result.current).toEqual({
             readableQueryString: searchStateString,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reltio/components",
-  "version": "1.4.2260",
+  "version": "1.4.2262",
   "license": "SEE LICENSE IN LICENSE FILE",
   "main": "./cjs/index.js",
   "module": "./index.js",
@@ -11,7 +11,7 @@
     "@fluentui/react-context-selector": "^9.1.26",
     "@googlemaps/markerclusterer": "^2.5.3",
     "@react-sigma/core": "3.4.0",
-    "@reltio/mdm-sdk": "^1.4.2041",
+    "@reltio/mdm-sdk": "^1.4.2043",
     "@vis.gl/react-google-maps": "^1.3.0",
     "d3-cloud": "^1.2.5",
     "d3-geo": "^2.0.1",