orc-shared 5.7.0-dev.0 → 5.7.0-dev.2

package/dist/utils/propertyBagHelper.js

@@ -0,0 +1,265 @@
+"use strict";
+
+exports.__esModule = true;
+exports.toJsonCargo = exports.setRequiredBooleansDefault = exports.isTieredAttribute = exports.getPropertyBagFormattedPrimitiveValue = exports.formatNumber = exports.fixPropertyBagModifiedModel = exports.fixPropertyBagEmptyValues = exports.customDataType = exports.createJsonCargo = void 0;
+var _constants = require("../constants");
+var _propertyValidator = require("./propertyValidator");
+var _sharedMessages = _interopRequireDefault(require("../sharedMessages"));
+var _parseHelper = require("./parseHelper");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+(function () {
+  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
+  enterModule && enterModule(module);
+})();
+(function () {
+  var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
+  enterModule && enterModule(module);
+})();
+var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
+  return a;
+};
+var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
+  return a;
+};
+var customDataType = exports.customDataType = {
+  money: "Money",
+  priceTieredRateTable: "PriceTieredRateTable",
+  quantityTieredRateTable: "QuantityTieredRateTable",
+  password: "Password",
+  carrierProviderSelector: "CarrierProviderSelector",
+  routingProviderSelector: "RoutingProviderSelector",
+  multipleCarrierProvidersSelector: "MultipleCarrierProvidersSelector"
+};
+var tieredAttributeTypes = [customDataType.priceTieredRateTable, customDataType.quantityTieredRateTable];
+var isTieredAttribute = exports.isTieredAttribute = function isTieredAttribute(attribute) {
+  return tieredAttributeTypes.includes(attribute.customDataType);
+};
+var buildValueOfType = function buildValueOfType(cargoType) {
+  return "ValueOf".concat(cargoType);
+};
+var buildValueContainerOfType = function buildValueContainerOfType(dotNetType) {
+  return "Orckestra.Overture.Entities.ValueContainer`1[[".concat(dotNetType, ", mscorlib]], Orckestra.Overture.Entities");
+};
+var createJsonCargo = exports.createJsonCargo = function createJsonCargo(cargoType, value) {
+  return {
+    __type: buildValueOfType(cargoType),
+    value: value
+  };
+};
+var createTieredTableJsonCargo = function createTieredTableJsonCargo(tiers) {
+  return {
+    __type: "Orckestra.Overture.Entities.Orders.TieredRateTable, Orckestra.Overture.Entities",
+    tiers: tiers.filter(function (tier) {
+      var _tier$min;
+      return ((_tier$min = tier == null ? void 0 : tier.min) != null ? _tier$min : "") !== "";
+    })
+  };
+};
+var toJsonCargo = exports.toJsonCargo = function toJsonCargo(attribute, value) {
+  switch (attribute.dataType) {
+    case _constants.attributeDataType.text:
+    case _constants.attributeDataType.lookup:
+      return value;
+    case _constants.attributeDataType.boolean:
+      return createJsonCargo(_constants.jsonCargoType.boolean, value);
+    case _constants.attributeDataType.integer:
+      return createJsonCargo(_constants.jsonCargoType.integer, Number(formatNumber(value, 0)));
+    case _constants.attributeDataType.decimal:
+      return createJsonCargo(_constants.jsonCargoType.double, Number(value));
+    case _constants.attributeDataType.dateTime:
+      return createJsonCargo(_constants.jsonCargoType.dateTime, value);
+    case _constants.attributeDataType.customType:
+      switch (attribute.customDataType) {
+        case customDataType.money:
+          return createJsonCargo(_constants.jsonCargoType.double, Number(formatNumber(value, 2)));
+        case customDataType.priceTieredRateTable:
+        case customDataType.quantityTieredRateTable:
+          return createTieredTableJsonCargo(value);
+        case customDataType.password:
+        case customDataType.carrierProviderSelector: // To be properly handled when user story 61801 will be addressed
+        case customDataType.routingProviderSelector: // To be properly handled when user story 61801 will be addressed
+        case customDataType.multipleCarrierProvidersSelector:
+          // To be properly handled when user story 61801 will be addressed
+          return value;
+        default:
+          throw new Error("toJsonCargo: attribute.customDataType ".concat(attribute.customDataType, " is not implemented"));
+      }
+    case _constants.attributeDataType.entityReference:
+      return createJsonCargo(_constants.jsonCargoType.entityReferences, value);
+    default:
+      throw new Error("toJsonCargo: attribute.dataType ".concat(attribute.dataType, " is not implemented"));
+  }
+};
+var dataTypesChecker = {
+  booleanDataTypes: [buildValueOfType(_constants.propertyBagPrimitiveDataType.boolean), buildValueContainerOfType(_constants.dotNetDataTypes.boolean)],
+  integerDataTypes: [buildValueOfType(_constants.propertyBagPrimitiveDataType.byte), buildValueContainerOfType(_constants.dotNetDataTypes.byte), buildValueOfType(_constants.propertyBagPrimitiveDataType.sbyte), buildValueContainerOfType(_constants.dotNetDataTypes.sbyte), buildValueOfType(_constants.propertyBagPrimitiveDataType.int16), buildValueContainerOfType(_constants.dotNetDataTypes.int16), buildValueOfType(_constants.propertyBagPrimitiveDataType.uint16), buildValueContainerOfType(_constants.dotNetDataTypes.uint16), buildValueOfType(_constants.propertyBagPrimitiveDataType.int32), buildValueContainerOfType(_constants.dotNetDataTypes.int32), buildValueOfType(_constants.propertyBagPrimitiveDataType.uint32), buildValueContainerOfType(_constants.dotNetDataTypes.uint32), buildValueOfType(_constants.propertyBagPrimitiveDataType.int64), buildValueContainerOfType(_constants.dotNetDataTypes.int64), buildValueOfType(_constants.propertyBagPrimitiveDataType.uint64), buildValueContainerOfType(_constants.dotNetDataTypes.uint64)],
+  textDataTypes: [buildValueOfType(_constants.propertyBagPrimitiveDataType.char), buildValueContainerOfType(_constants.dotNetDataTypes.char), buildValueOfType(_constants.propertyBagPrimitiveDataType.string), buildValueContainerOfType(_constants.dotNetDataTypes.string)],
+  decimalDataTypes: [buildValueOfType(_constants.propertyBagPrimitiveDataType.single), buildValueContainerOfType(_constants.dotNetDataTypes.single), buildValueOfType(_constants.propertyBagPrimitiveDataType.double), buildValueContainerOfType(_constants.dotNetDataTypes.double), buildValueOfType(_constants.propertyBagPrimitiveDataType.decimal), buildValueContainerOfType(_constants.dotNetDataTypes.decimal)],
+  dateTimeDataTypes: [buildValueOfType(_constants.propertyBagPrimitiveDataType.dateTime), buildValueContainerOfType(_constants.dotNetDataTypes.dateTime)],
+  guidDataTypes: [buildValueOfType(_constants.propertyBagPrimitiveDataType.guid), buildValueContainerOfType(_constants.dotNetDataTypes.guid)],
+  isBoolean: function isBoolean(type) {
+    return dataTypesChecker.booleanDataTypes.includes(type);
+  },
+  isInteger: function isInteger(type) {
+    return dataTypesChecker.integerDataTypes.includes(type);
+  },
+  isText: function isText(type) {
+    return dataTypesChecker.textDataTypes.includes(type);
+  },
+  isDecimal: function isDecimal(type) {
+    return dataTypesChecker.decimalDataTypes.includes(type);
+  },
+  isDateTime: function isDateTime(type) {
+    return dataTypesChecker.dateTimeDataTypes.includes(type);
+  },
+  isGuid: function isGuid(type) {
+    return dataTypesChecker.guidDataTypes.includes(type);
+  }
+};
+var getPropertyBagFormattedPrimitiveValue = exports.getPropertyBagFormattedPrimitiveValue = function getPropertyBagFormattedPrimitiveValue(propertyBagValue, formatMessage, formatDate, formatTime) {
+  if (propertyBagValue === null || propertyBagValue === undefined || !(0, _propertyValidator.isObject)(propertyBagValue)) {
+    return propertyBagValue;
+  }
+  if (propertyBagValue.value === null || propertyBagValue.value === undefined) {
+    return null;
+  }
+  if (dataTypesChecker.isBoolean(propertyBagValue[_constants.serializationTypeKey])) {
+    return Boolean(propertyBagValue.value) ? formatMessage(_sharedMessages.default.valueTypeWrapperTrue) : formatMessage(_sharedMessages.default.valueTypeWrapperFalse);
+  }
+  if (dataTypesChecker.isInteger(propertyBagValue[_constants.serializationTypeKey])) {
+    return formatNumber(propertyBagValue.value, 0);
+  }
+  if (dataTypesChecker.isText(propertyBagValue[_constants.serializationTypeKey])) {
+    return propertyBagValue.value.toString();
+  }
+  if (dataTypesChecker.isDecimal(propertyBagValue[_constants.serializationTypeKey])) {
+    return formatNumber(propertyBagValue.value, 2);
+  }
+  if (dataTypesChecker.isDateTime(propertyBagValue[_constants.serializationTypeKey])) {
+    return "".concat(formatDate(propertyBagValue.value), " ").concat(formatTime(propertyBagValue.value));
+  }
+  if (dataTypesChecker.isGuid(propertyBagValue[_constants.serializationTypeKey])) {
+    return (0, _parseHelper.parseGuid)(propertyBagValue.value);
+  }
+
+  // we ignore other data types since we have no way to format them
+  return null;
+};
+var formatNumber = exports.formatNumber = function formatNumber(value, precision) {
+  return Number(value).toFixed(precision);
+};
+var fixPropertyBagModifiedModel = exports.fixPropertyBagModifiedModel = function fixPropertyBagModifiedModel(model) {
+  var fixProfileOperations = function fixProfileOperations(model) {
+    if (model.hasOwnProperty("profileOperations")) {
+      var _model$profileOperati = model.profileOperations,
+        profilesToAdd = _model$profileOperati.profilesToAdd,
+        profilesToUpdate = _model$profileOperati.profilesToUpdate;
+      if (profilesToAdd) {
+        var items = Array.isArray(profilesToAdd) ? profilesToAdd : Object.values(profilesToAdd);
+        items.forEach(function (pr) {
+          fixPropertyBagEmptyValues(pr.propertyBag);
+        });
+      }
+      if (profilesToUpdate) {
+        var _items = Array.isArray(profilesToUpdate) ? profilesToUpdate : Object.values(profilesToUpdate);
+        _items.forEach(function (pr) {
+          fixPropertyBagEmptyValues(pr.propertyBag);
+        });
+      }
+    }
+  };
+  fixPropertyBagEmptyValues(model.propertyBag);
+  fixProfileOperations(model);
+  for (var _len = arguments.length, fields = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    fields[_key - 1] = arguments[_key];
+  }
+  fields.forEach(function (field) {
+    var _model$field;
+    var fieldValue = (_model$field = model[field]) == null ? void 0 : _model$field.value;
+    if (!fieldValue) return;
+    if (Array.isArray(fieldValue)) {
+      fieldValue.forEach(function (fieldItem) {
+        fixPropertyBagEmptyValues(fieldItem.propertyBag);
+        fixProfileOperations(fieldItem);
+      });
+    } else {
+      fixPropertyBagEmptyValues(fieldValue.propertyBag);
+    }
+  });
+};
+var fixPropertyBagEmptyValues = exports.fixPropertyBagEmptyValues = function fixPropertyBagEmptyValues(propertyBag) {
+  if (!propertyBag) return;
+  //we need to pass null to backend to remove attribute instead of empty string
+  //in case if attribute has validation for min length and when we will pass empty string, then we will get error from platform
+  //in case if DateTime attribute has empty value Backend will transform it to some '01/01/1900' date, so we need to pass null
+  var modifiedFields = Object.keys(propertyBag);
+  modifiedFields.forEach(function (propertyName) {
+    var property = propertyBag[propertyName];
+    var propertyValue = property && (0, _propertyValidator.isObject)(property) && property.hasOwnProperty("value") ? property.value : property;
+    if (propertyValue === "") {
+      propertyBag[propertyName] = null;
+    }
+  });
+};
+var setRequiredBooleansDefault = exports.setRequiredBooleansDefault = function setRequiredBooleansDefault(attributes, propertyBag) {
+  var requiredBools = attributes.filter(function (a) {
+    return a.isRequired && a.dataType === _constants.attributeDataType.boolean;
+  });
+  requiredBools.forEach(function (attr) {
+    if (!propertyBag[attr.name]) {
+      propertyBag[attr.name] = toJsonCargo(attr, false);
+    }
+  });
+};
+;
+(function () {
+  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
+  if (!reactHotLoader) {
+    return;
+  }
+  reactHotLoader.register(customDataType, "customDataType", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(tieredAttributeTypes, "tieredAttributeTypes", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(isTieredAttribute, "isTieredAttribute", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(buildValueOfType, "buildValueOfType", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(buildValueContainerOfType, "buildValueContainerOfType", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(createJsonCargo, "createJsonCargo", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(createTieredTableJsonCargo, "createTieredTableJsonCargo", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(toJsonCargo, "toJsonCargo", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(dataTypesChecker, "dataTypesChecker", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(getPropertyBagFormattedPrimitiveValue, "getPropertyBagFormattedPrimitiveValue", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(formatNumber, "formatNumber", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(fixPropertyBagModifiedModel, "fixPropertyBagModifiedModel", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(fixPropertyBagEmptyValues, "fixPropertyBagEmptyValues", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(setRequiredBooleansDefault, "setRequiredBooleansDefault", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+})();
+;
+(function () {
+  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
+  leaveModule && leaveModule(module);
+})();
+;
+(function () {
+  var reactHotLoader = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default : undefined;
+  if (!reactHotLoader) {
+    return;
+  }
+  reactHotLoader.register(customDataType, "customDataType", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(tieredAttributeTypes, "tieredAttributeTypes", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(isTieredAttribute, "isTieredAttribute", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(buildValueOfType, "buildValueOfType", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(buildValueContainerOfType, "buildValueContainerOfType", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(createJsonCargo, "createJsonCargo", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(createTieredTableJsonCargo, "createTieredTableJsonCargo", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(toJsonCargo, "toJsonCargo", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(dataTypesChecker, "dataTypesChecker", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(getPropertyBagFormattedPrimitiveValue, "getPropertyBagFormattedPrimitiveValue", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(formatNumber, "formatNumber", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(fixPropertyBagModifiedModel, "fixPropertyBagModifiedModel", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(fixPropertyBagEmptyValues, "fixPropertyBagEmptyValues", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+  reactHotLoader.register(setRequiredBooleansDefault, "setRequiredBooleansDefault", "/home/vsts/work/1/s/src/utils/propertyBagHelper.js");
+})();
+;
+(function () {
+  var leaveModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.leaveModule : undefined;
+  leaveModule && leaveModule(module);
+})();

package/dist/utils/responseProcessingHelper.js

@@ -2,6 +2,7 @@
 
 exports.__esModule = true;
 exports.extractStandardErrorMessagesFromResponse = void 0;
+var _propertyBagHelper = require("./propertyBagHelper");
 (function () {
   var enterModule = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.enterModule : undefined;
   enterModule && enterModule(module);
@@ -16,7 +17,17 @@ var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoader
 var __signature__ = typeof reactHotLoaderGlobal !== 'undefined' ? reactHotLoaderGlobal.default.signature : function (a) {
   return a;
 };
-var extractStandardErrorMessagesFromResponse = exports.extractStandardErrorMessagesFromResponse = function extractStandardErrorMessagesFromResponse(response, validationLookupModule, validationLookupName) {
+var parseFailureContext = function parseFailureContext(context, formatMessage, formatDate, formatTime) {
+  if (!context) {
+    return context;
+  }
+  var newContext = {};
+  Object.keys(context).forEach(function (key) {
+    newContext[key] = (0, _propertyBagHelper.getPropertyBagFormattedPrimitiveValue)(context[key], formatMessage, formatDate, formatTime);
+  });
+  return newContext;
+};
+var extractStandardErrorMessagesFromResponse = exports.extractStandardErrorMessagesFromResponse = function extractStandardErrorMessagesFromResponse(response, validationLookupModule, validationLookupName, formatMessage, formatDate, formatTime, lookupKeyCustomizer) {
   var hasErrors = false;
   var messages = [];
   if (response != null && response.error) {
@@ -32,7 +43,8 @@ var extractStandardErrorMessagesFromResponse = exports.extractStandardErrorMessa
               message: failure.errorMessage,
               lookupModule: validationLookupModule,
               lookupName: validationLookupName,
-              lookupKey: failure.errorCode
+              lookupKey: lookupKeyCustomizer ? lookupKeyCustomizer(failure.errorCode) : failure.errorCode,
+              lookupReplacementValues: parseFailureContext(failure.context, formatMessage, formatDate, formatTime)
             });
           }
         });
@@ -46,7 +58,7 @@ var extractStandardErrorMessagesFromResponse = exports.extractStandardErrorMessa
             message: err.message,
             lookupModule: err.lookupModule,
             lookupName: err.lookupName,
-            lookupKey: err.lookupKey,
+            lookupKey: lookupKeyCustomizer ? lookupKeyCustomizer(err.lookupKey) : err.lookupKey,
             lookupReplacementValues: err.lookupReplacementValues
           });
         });
@@ -64,6 +76,7 @@ var extractStandardErrorMessagesFromResponse = exports.extractStandardErrorMessa
   if (!reactHotLoader) {
     return;
   }
+  reactHotLoader.register(parseFailureContext, "parseFailureContext", "/home/vsts/work/1/s/src/utils/responseProcessingHelper.js");
   reactHotLoader.register(extractStandardErrorMessagesFromResponse, "extractStandardErrorMessagesFromResponse", "/home/vsts/work/1/s/src/utils/responseProcessingHelper.js");
 })();
 ;
@@ -77,6 +90,7 @@ var extractStandardErrorMessagesFromResponse = exports.extractStandardErrorMessa
   if (!reactHotLoader) {
     return;
   }
+  reactHotLoader.register(parseFailureContext, "parseFailureContext", "/home/vsts/work/1/s/src/utils/responseProcessingHelper.js");
   reactHotLoader.register(extractStandardErrorMessagesFromResponse, "extractStandardErrorMessagesFromResponse", "/home/vsts/work/1/s/src/utils/responseProcessingHelper.js");
 })();
 ;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "orc-shared",
-	"version": "5.7.0-dev.0",
+	"version": "5.7.0-dev.2",
 	"description": "Shared code for Orckestra applications",
 	"main": "./src/index.js",
 	"exports": {

package/src/components/MaterialUI/Inputs/InputBase.js

@@ -137,6 +137,24 @@ const InputBase = ({ inputProps }) => {
 		});
 	}
 
+	if (isAdvancedNumericInput) {
+		if (inputAttributes.max === undefined) {
+			inputAttributes.max = 2147483647;
+		}
+
+		if (inputAttributes.min === undefined) {
+			inputAttributes.min = -2147483648;
+		}
+
+		inputAttributes.isAllowed = val => {
+			return (
+				val.value === "" ||
+				val.value === "-" ||
+				(val.floatValue >= inputAttributes.min && val.floatValue <= inputAttributes.max)
+			);
+		};
+	}
+
 	const defaultRows = 4;
 	let rows = rowsProps;
 	if (rows === null || rows === undefined) rows = defaultRows;

package/src/components/MaterialUI/Inputs/InputBase.test.js

@@ -685,4 +685,160 @@ describe("AdvancedNumericInput", () => {
 
 		// no idea what to assert here, this test is mostly for code coverage
 	});
+
+	it("Change advanced numeric input value with min value out of default bounds", () => {
+		const inputProps = new InputBaseProps();
+		const aLabel = "aLabel";
+		const aValue = "12.2";
+		const metadata = {
+			test: "value",
+		};
+
+		inputProps.set(InputBaseProps.propNames.update, update);
+		inputProps.set(InputBaseProps.propNames.value, aValue);
+		inputProps.set(InputBaseProps.propNames.label, aLabel);
+		inputProps.set(InputBaseProps.propNames.type, "AdvancedNumericInput");
+		inputProps.set(InputBaseProps.propNames.numericInputProps, { decimalScale: 2 });
+		inputProps.set(InputBaseProps.propNames.metadata, metadata);
+
+		const component = <InputBase inputProps={inputProps} />;
+		const mountedComponent = mount(component);
+		const input = mountedComponent.find("input");
+		input.simulate("change", { target: { value: "-3147483648", focus: noop } });
+
+		expect(update, "not to have calls satisfying", [{ args: ["-3147483648", metadata] }]);
+
+		input.simulate("change", { target: { value: "-111", focus: noop } });
+		expect(update, "to have calls satisfying", [{ args: ["-111", metadata] }]);
+	});
+
+	it("Change advanced numeric input value with min value out of specified bounds", () => {
+		const inputProps = new InputBaseProps();
+		const aLabel = "aLabel";
+		const aValue = "12.2";
+		const metadata = {
+			test: "value",
+		};
+
+		inputProps.set(InputBaseProps.propNames.update, update);
+		inputProps.set(InputBaseProps.propNames.value, aValue);
+		inputProps.set(InputBaseProps.propNames.label, aLabel);
+		inputProps.set(InputBaseProps.propNames.type, "AdvancedNumericInput");
+		inputProps.set(InputBaseProps.propNames.numericInputProps, { decimalScale: 2 });
+		inputProps.set(InputBaseProps.propNames.metadata, metadata);
+		inputProps.set(InputBaseProps.propNames.inputAttributes, {
+			min: -100,
+		});
+
+		const component = <InputBase inputProps={inputProps} />;
+		const mountedComponent = mount(component);
+		const input = mountedComponent.find("input");
+		input.simulate("change", { target: { value: "-2000", focus: noop } });
+
+		expect(update, "not to have calls satisfying", [{ args: ["-2000", metadata] }]);
+
+		input.simulate("change", { target: { value: "-11", focus: noop } });
+		expect(update, "to have calls satisfying", [{ args: ["-11", metadata] }]);
+	});
+
+	it("Change advanced numeric input value with max value out of default bounds", () => {
+		const inputProps = new InputBaseProps();
+		const aLabel = "aLabel";
+		const aValue = "12.2";
+		const metadata = {
+			test: "value",
+		};
+
+		inputProps.set(InputBaseProps.propNames.update, update);
+		inputProps.set(InputBaseProps.propNames.value, aValue);
+		inputProps.set(InputBaseProps.propNames.label, aLabel);
+		inputProps.set(InputBaseProps.propNames.type, "AdvancedNumericInput");
+		inputProps.set(InputBaseProps.propNames.numericInputProps, { decimalScale: 2 });
+		inputProps.set(InputBaseProps.propNames.metadata, metadata);
+
+		const component = <InputBase inputProps={inputProps} />;
+		const mountedComponent = mount(component);
+		const input = mountedComponent.find("input");
+		input.simulate("change", { target: { value: "3147483648", focus: noop } });
+
+		expect(update, "not to have calls satisfying", [{ args: ["3147483648", metadata] }]);
+
+		input.simulate("change", { target: { value: "111", focus: noop } });
+		expect(update, "to have calls satisfying", [{ args: ["111", metadata] }]);
+	});
+
+	it("Change advanced numeric input value with max value out of specified bounds", () => {
+		const inputProps = new InputBaseProps();
+		const aLabel = "aLabel";
+		const aValue = "12.2";
+		const metadata = {
+			test: "value",
+		};
+
+		inputProps.set(InputBaseProps.propNames.update, update);
+		inputProps.set(InputBaseProps.propNames.value, aValue);
+		inputProps.set(InputBaseProps.propNames.label, aLabel);
+		inputProps.set(InputBaseProps.propNames.type, "AdvancedNumericInput");
+		inputProps.set(InputBaseProps.propNames.numericInputProps, { decimalScale: 2 });
+		inputProps.set(InputBaseProps.propNames.metadata, metadata);
+		inputProps.set(InputBaseProps.propNames.inputAttributes, {
+			max: 100,
+		});
+
+		const component = <InputBase inputProps={inputProps} />;
+		const mountedComponent = mount(component);
+		const input = mountedComponent.find("input");
+		input.simulate("change", { target: { value: "2000", focus: noop } });
+
+		expect(update, "not to have calls satisfying", [{ args: ["2000", metadata] }]);
+
+		input.simulate("change", { target: { value: "11", focus: noop } });
+		expect(update, "to have calls satisfying", [{ args: ["11", metadata] }]);
+	});
+
+	it("Change advanced numeric input value: dash is allowed", () => {
+		const inputProps = new InputBaseProps();
+		const aLabel = "aLabel";
+		const aValue = "12.2";
+		const metadata = {
+			test: "value",
+		};
+
+		inputProps.set(InputBaseProps.propNames.update, update);
+		inputProps.set(InputBaseProps.propNames.value, aValue);
+		inputProps.set(InputBaseProps.propNames.label, aLabel);
+		inputProps.set(InputBaseProps.propNames.type, "AdvancedNumericInput");
+		inputProps.set(InputBaseProps.propNames.numericInputProps, { decimalScale: 2 });
+		inputProps.set(InputBaseProps.propNames.metadata, metadata);
+
+		const component = <InputBase inputProps={inputProps} />;
+		const mountedComponent = mount(component);
+		const input = mountedComponent.find("input");
+		input.simulate("change", { target: { value: "-", focus: noop } });
+
+		expect(update, "to have calls satisfying", [{ args: ["-", metadata] }]);
+	});
+
+	it("Change advanced numeric input value: empty value is allowed", () => {
+		const inputProps = new InputBaseProps();
+		const aLabel = "aLabel";
+		const aValue = "12.2";
+		const metadata = {
+			test: "value",
+		};
+
+		inputProps.set(InputBaseProps.propNames.update, update);
+		inputProps.set(InputBaseProps.propNames.value, aValue);
+		inputProps.set(InputBaseProps.propNames.label, aLabel);
+		inputProps.set(InputBaseProps.propNames.type, "AdvancedNumericInput");
+		inputProps.set(InputBaseProps.propNames.numericInputProps, { decimalScale: 2 });
+		inputProps.set(InputBaseProps.propNames.metadata, metadata);
+
+		const component = <InputBase inputProps={inputProps} />;
+		const mountedComponent = mount(component);
+		const input = mountedComponent.find("input");
+		input.simulate("change", { target: { value: "", focus: noop } });
+
+		expect(update, "to have calls satisfying", [{ args: ["", metadata] }]);
+	});
 });

package/src/components/Routing/SubPage.js

@@ -47,11 +47,12 @@ export const SubPage = ({ config, match, location, history, root, modulePrependP
 
 	const modalProps = new ModalProps();
 
-	const titleComponent = props?.title?.id ? (
-		<FormattedMessage id={props?.title?.id} defaultMesaage={props?.title?.defaultMessage} />
-	) : (
-		props?.title
-	);
+	const formattedMsgProps = {
+		id: props?.title?.id,
+		defaultMessage: props?.title?.defaultMessage,
+	};
+
+	const titleComponent = props?.title?.id ? <FormattedMessage {...formattedMsgProps} /> : props?.title;
 
 	modalProps.set(ModalProps.propNames.title, titleComponent);
 	modalProps.set(ModalProps.propNames.open, true);

package/src/constants.js

@@ -120,3 +120,51 @@ export const taskStatuses = {
 	ignored: "Ignored",
 	queuedForSequence: "QueuedForSequence",
 };
+
+export const propertyBagPrimitiveDataType = {
+	boolean: "Boolean",
+	byte: "Byte",
+	sbyte: "SByte",
+	int16: "Int16",
+	uint16: "UInt16",
+	int32: "Int32",
+	uint32: "UInt32",
+	int64: "Int64",
+	uint64: "UInt64",
+	single: "Single",
+	double: "Double",
+	decimal: "Decimal",
+	dateTime: "DateTime",
+	char: "Char",
+	string: "String",
+	guid: "Guid",
+};
+
+export const dotNetDataTypes = {
+	boolean: "System.Boolean",
+	byte: "System.Byte",
+	sbyte: "System.SByte",
+	int16: "System.Int16",
+	uint16: "System.UInt16",
+	int32: "System.Int32",
+	uint32: "System.UInt32",
+	int64: "System.Int64",
+	uint64: "System.UInt64",
+	single: "System.Single",
+	double: "System.Double",
+	decimal: "System.Decimal",
+	dateTime: "System.DateTime",
+	char: "System.Char",
+	string: "System.String",
+	guid: "System.Guid",
+};
+
+export const serializationTypeKey = "__type";
+
+export const jsonCargoType = {
+	boolean: "Boolean",
+	double: "Double",
+	dateTime: "DateTime",
+	integer: "Int32",
+	entityReferences: "Guid[]",
+};

package/src/hooks/useDispatchWithErrorHandling.js

@@ -2,6 +2,7 @@ import { useDispatch } from "react-redux";
 import { useCallback } from "react";
 import { extractStandardErrorMessagesFromResponse } from "../utils/responseProcessingHelper";
 import { pushGlobalErrorMessage } from "../actions/globalErrorMessages";
+import { useIntl } from "react-intl";
 
 export const executeDispatchWithErrorHandling = ({
 	dispatch,
@@ -10,12 +11,20 @@ export const executeDispatchWithErrorHandling = ({
 	errorDescription,
 	validationLookupModule,
 	validationLookupName,
+	formatMessage,
+	formatDate,
+	formatTime,
+	lookupKeyCustomizer = null,
 }) => {
 	return dispatch(action).then(data => {
 		const extractedMessages = extractStandardErrorMessagesFromResponse(
 			data,
 			validationLookupModule,
 			validationLookupName,
+			formatMessage,
+			formatDate,
+			formatTime,
+			lookupKeyCustomizer,
 		);
 		if (extractedMessages.hasErrors) {
 			const newMsg = {
@@ -38,9 +47,10 @@ export const executeDispatchWithErrorHandling = ({
 
 export const useDispatchWithErrorHandling = () => {
 	const dispatch = useDispatch();
+	const { formatMessage, formatDate, formatTime } = useIntl();
 
 	return useCallback(
-		({ action, errorTitle, errorDescription, validationLookupModule, validationLookupName }) => {
+		({ action, errorTitle, errorDescription, validationLookupModule, validationLookupName, lookupKeyCustomizer }) => {
 			return executeDispatchWithErrorHandling({
 				dispatch,
 				action,
@@ -48,9 +58,13 @@ export const useDispatchWithErrorHandling = () => {
 				errorDescription,
 				validationLookupModule,
 				validationLookupName,
+				formatMessage,
+				formatDate,
+				formatTime,
+				lookupKeyCustomizer,
 			});
 		},
-		[dispatch],
+		[dispatch, formatDate, formatMessage, formatTime],
 	);
 };