@openui5/sap.ui.mdc 1.99.1 → 1.102.0

package/src/sap/ui/mdc/condition/FilterOperatorUtil.js

@@ -56,7 +56,7 @@ function(
 		 *
 		 * @namespace
 		 * @author SAP SE
-		 * @version 1.99.1
+		 * @version 1.102.0
 		 * @since 1.73.0
 		 * @alias sap.ui.mdc.condition.FilterOperatorUtil
 		 *
@@ -70,7 +70,7 @@ function(
 				_mOperators: {
 					equal: new Operator({
 						name: "EQ",
-						alias: "DATE",
+						alias: {Date: "DATE", DateTime: "DATETIME"},
 						filterOperator: ModelOperator.EQ,
 						tokenParse: "^=([^=].*)$",
 						tokenFormat: "{1} ({0})", // all placeholder should use the {x} format - the text could be store in the resourcebundel file.
@@ -81,7 +81,7 @@ function(
 							Description: "{1}",
 							Value: "{0}"
 						},
-						format: function(oCondition, oType, sDisplayFormat, bHideOperator) {
+						format: function(oCondition, oType, sDisplayFormat, bHideOperator, aCompositeTypes) {
 							sDisplayFormat = sDisplayFormat || FieldDisplay.DescriptionValue;
 							var iCount = this.valueTypes.length;
 							var aValues = oCondition.values;
@@ -100,26 +100,30 @@ function(
 									vValue = "";
 								}
 
-								if (i == 0 && oType && (typeof oType.formatValue === "function")) {
+								if (i == 0) {
 									// only the first value can be formatted. second value is the description string
-									sReplace = oType.formatValue(vValue, "string");
+									sReplace = this._formatValue(vValue, oType, aCompositeTypes);
 								} else {
 									sReplace = vValue;
 								}
 
-								sTokenText = sReplace == null ? null : sTokenText.replace(new RegExp("\\$" + i + "|" + i + "\\$" + "|" + "\\{" + i + "\\}", "g"), sReplace);
+								if (sReplace === null) {
+									sTokenText = null; // some types (like Unit) return null if no value is given, in this case stop formating and return null
+									break;
+								}
+								sTokenText = sTokenText.replace(new RegExp("\\$" + i + "|" + i + "\\$" + "|" + "\\{" + i + "\\}", "g"), sReplace);
 							}
 
 							return sTokenText;
 						},
-						parse: function(sText, oType, sDisplayFormat, bDefaultOperator) {
+						parse: function(sText, oType, sDisplayFormat, bDefaultOperator, aCompositeTypes) {
 							sDisplayFormat = sDisplayFormat || FieldDisplay.DescriptionValue;
-							var aResult = Operator.prototype.parse.apply(this, [sText, oType, sDisplayFormat, bDefaultOperator]);
+							var aResult = Operator.prototype.parse.apply(this, [sText, oType, sDisplayFormat, bDefaultOperator, aCompositeTypes]);
 
 							if (bDefaultOperator && (!aResult || aResult[0] === null || aResult[0] === undefined) && sDisplayFormat !== FieldDisplay.Value) {
 								// in default case and no key determined (simple-EQ case)-> use text as key (parse again to use type)
 								sDisplayFormat = FieldDisplay.Value;
-								aResult = Operator.prototype.parse.apply(this, [sText, oType, sDisplayFormat, bDefaultOperator]);
+								aResult = Operator.prototype.parse.apply(this, [sText, oType, sDisplayFormat, bDefaultOperator, aCompositeTypes]);
 							}
 							if (aResult && (aResult[1] === null || aResult[1] === undefined) && sDisplayFormat === FieldDisplay.Value) {
 								aResult = [aResult[0]]; // only key
@@ -207,7 +211,7 @@ function(
 					}),
 					between: new Operator({
 						name: "BT",
-						alias: "DATERANGE",
+						alias: {Date: "DATERANGE", DateTime:"DATETIMERANGE"},
 						filterOperator: ModelOperator.BT,
 						tokenParse: "^([^!].*)\\.\\.\\.(.+)$", // TODO: does this work?? At least also matches crap like ".....". I guess validation of value types needs to get rid of those.
 						tokenFormat: "{0}...{1}",
@@ -276,7 +280,7 @@ function(
 					}),
 					lessEqual: new Operator({
 						name: "LE",
-						alias: "TO",
+						alias: {Date: "TO", DateTime: "TODATETIME"},
 						filterOperator: ModelOperator.LE,
 						tokenParse: "^<=(.+)$",
 						tokenFormat: "<={0}",
@@ -292,7 +296,7 @@ function(
 					}),
 					greaterEqual: new Operator({
 						name: "GE",
-						alias: "FROM",
+						alias: {Date: "FROM", DateTime: "FROMDATETIME"},
 						filterOperator: ModelOperator.GE,
 						tokenParse: "^>=(.+)$",
 						tokenFormat: ">={0}",
@@ -365,7 +369,7 @@ function(
 						tokenParse: "^<#tokenText#>$",
 						tokenFormat: "<#tokenText#>",
 						valueTypes: [],
-						getModelFilter: function(oCondition, sFieldPath, oType, bCaseSensitive) {
+						getModelFilter: function(oCondition, sFieldPath, oType, bCaseSensitive, sBaseType) {
 							var isNullable = false;
 							if (oType) {
 								var vResult = oType.parseValue("", "string");
@@ -397,7 +401,7 @@ function(
 						tokenFormat: "!(<#tokenText#>)",
 						valueTypes: [],
 						exclude: true,
-						getModelFilter: function(oCondition, sFieldPath, oType, bCaseSensitive) {
+						getModelFilter: function(oCondition, sFieldPath, oType, bCaseSensitive, sBaseType) {
 							var isNullable = false;
 							if (oType) {
 								var vResult = oType.parseValue("", "string");
@@ -544,7 +548,6 @@ function(
 						}
 					}),
 					todayFromTo: new RangeOperator({
-						alias: "TODAYXYDAYS",
 						name: "TODAYFROMTO",
 						valueTypes: [
 							{name: "sap.ui.model.type.Integer", formatOptions: { emptyString: null }},
@@ -581,7 +584,6 @@ function(
 						}
 					}),
 					thisWeek: new RangeOperator({
-						alias: "CURRENTWEEK",
 						name: "THISWEEK",
 						valueTypes: [Operator.ValueType.Static],
 						calcRange: function() {
@@ -621,7 +623,6 @@ function(
 						}
 					}),
 					thisMonth: new RangeOperator({
-						alias: "CURRENTMONTH",
 						name: "THISMONTH",
 						valueTypes: [Operator.ValueType.Static],
 						calcRange: function() {
@@ -661,7 +662,6 @@ function(
 						}
 					}),
 					thisQuarter: new RangeOperator({
-						alias: "CURRENTQUARTER",
 						name: "THISQUARTER",
 						valueTypes: [Operator.ValueType.Static],
 						calcRange: function() {
@@ -694,7 +694,6 @@ function(
 						}
 					}),
 					quarter1: new RangeOperator({
-						alias: "FIRSTQUARTER",
 						name: "QUARTER1",
 						valueTypes: [Operator.ValueType.Static],
 						calcRange: function() {
@@ -702,7 +701,6 @@ function(
 						}
 					}),
 					quarter2: new RangeOperator({
-						alias: "SECONDQUARTER",
 						name: "QUARTER2",
 						valueTypes: [Operator.ValueType.Static],
 						calcRange: function() {
@@ -710,7 +708,6 @@ function(
 						}
 					}),
 					quarter3: new RangeOperator({
-						alias: "THIRDQUARTER",
 						name: "QUARTER3",
 						valueTypes: [Operator.ValueType.Static],
 						calcRange: function() {
@@ -718,7 +715,6 @@ function(
 						}
 					}),
 					quarter4: new RangeOperator({
-						alias: "FOURTHQUARTER",
 						name: "QUARTER4",
 						valueTypes: [Operator.ValueType.Static],
 						calcRange: function() {
@@ -733,7 +729,6 @@ function(
 						}
 					}),
 					thisYear: new RangeOperator({
-						alias: "CURRENTYEAR",
 						name: "THISYEAR",
 						valueTypes: [Operator.ValueType.Static],
 						calcRange: function() {
@@ -783,7 +778,7 @@ function(
 							oDate = UniversalDateUtils.getMonthStartDate(oDate);
 							return UniversalDateUtils.getRange(0, "MONTH", oDate);
 						},
-						format: function(oCondition, oType, sDisplayFormat, bHideOperator) {
+						format: function(oCondition, oType, sDisplayFormat, bHideOperator, aCompositeTypes) {
 							var iValue = oCondition.values[0];
 							var sTokenText = this.tokenFormat;
 							var sReplace = _getMonths.apply(this)[iValue];
@@ -853,7 +848,7 @@ function(
 							oDate = UniversalDateUtils.getMonthStartDate(oDate);
 							return UniversalDateUtils.getRange(0, "MONTH", oDate);
 						},
-						format: function(oCondition, oType, sDisplayFormat, bHideOperator) {
+						format: function(oCondition, oType, sDisplayFormat, bHideOperator, aCompositeTypes) {
 							var iValue = oCondition.values[0];
 							var iYear = oCondition.values[1];
 							var sTokenText = this.tokenFormat;
@@ -1223,14 +1218,7 @@ function(
 
 					for (var sName in FilterOperatorUtil._mOperators) {
 						var oOperator = FilterOperatorUtil._mOperators[sName];
-						if ( oOperator.name === sOperator) {
-							return oOperator;
-						}
-					}
-
-					for (var sName in FilterOperatorUtil._mOperators) {
-						var oOperator = FilterOperatorUtil._mOperators[sName];
-						if ( oOperator.alias === sOperator) {
+						if (oOperator.name === sOperator) {
 							return oOperator;
 						}
 					}
@@ -1477,6 +1465,81 @@ function(
 						oOperator.checkValidated(oCondition);
 					}
 
+				},
+
+				/**
+				 * Returns the operator object for the given <code>DynamicDateOption</code> name.
+				 * @param {string} sOption Name of the operator
+				 * @param {sap.ui.mdc.enum.BaseType} [sBaseType] Basic type
+				 * @returns {sap.ui.mdc.condition.Operator} the operator object, or undefined if the operator with the requested name does not exist
+				 *
+				 * @protected
+				 * @since: 1.100.0
+				 */
+				 getOperatorForDynamicDateOption: function(sOption, sBaseType) {
+
+					var oOperator;
+
+					// determine operator name if used as custom DynamicDateOption created in DateContent using getCustomDynamicDateOptionForOperator
+					if (sBaseType && sOption.startsWith(sBaseType)) {
+						oOperator = this.getOperator(sOption.slice(sBaseType.length + 1));
+					} else {
+						oOperator = this.getOperator(sOption);
+					}
+
+					if (!oOperator && sBaseType) {
+						for (var sName in FilterOperatorUtil._mOperators) {
+							var oCheckOperator = FilterOperatorUtil._mOperators[sName];
+							if (oCheckOperator.alias && oCheckOperator.alias[sBaseType] === sOption) {
+								oOperator = oCheckOperator;
+								break;
+							}
+						}
+					}
+
+					return oOperator;
+
+				},
+
+				/**
+				 * Determines the corresponding <code>DynamicDateOption</code> for an <code>Operator</code>
+				 * from a map of known keys
+				 *
+				 * @param {sap.ui.mdc.condition.Operator} oOperator Condition to check
+				 * @param {object} oDynamicDateRangeKeys Keys for <code>DynamicDateOption</code>
+				 * @param {sap.ui.mdc.enum.BaseType} sBaseType Basic type
+				 * @returns {string} <code>DynamicDateOption</code>
+				 * @protected
+				 * @since: 1.100.0
+				 */
+				 getDynamicDateOptionForOperator: function(oOperator, oDynamicDateRangeKeys, sBaseType) {
+
+					var sOption;
+					if (oOperator) {
+						if (oDynamicDateRangeKeys[oOperator.name]) {
+							sOption = oOperator.name;
+						} else if (oOperator.alias && oDynamicDateRangeKeys[oOperator.alias[sBaseType]]) {
+							sOption = oOperator.alias[sBaseType];
+						}
+					}
+
+					return sOption;
+
+				},
+
+				/**
+				 * Determines the corresponding custom <code>DynamicDateOption</code> for an <code>Operator</code>
+				 *
+				 * @param {sap.ui.mdc.condition.Operator} oOperator Condition to check
+				 * @param {sap.ui.mdc.enum.BaseType} sBaseType Basic type
+				 * @returns {string} <code>DynamicDateOption</code>
+				 * @protected
+				 * @since: 1.100.0
+				 */
+				 getCustomDynamicDateOptionForOperator: function(oOperator, sBaseType) {
+
+					return sBaseType + "-" + oOperator.name;
+
 				}
 		};
 
@@ -1591,7 +1654,56 @@ function(
 				 FilterOperatorUtil._mOperators.notLessThan,
 				 FilterOperatorUtil._mOperators.notLessEqual,
 				 FilterOperatorUtil._mOperators.notGreaterThan,
-				 FilterOperatorUtil._mOperators.notGreaterEqual
+				 FilterOperatorUtil._mOperators.notGreaterEqual,
+
+				 FilterOperatorUtil._mOperators.today,
+				 FilterOperatorUtil._mOperators.yesterday,
+				 FilterOperatorUtil._mOperators.tomorrow,
+				 FilterOperatorUtil._mOperators.firstDayWeek,
+				 FilterOperatorUtil._mOperators.lastDayWeek,
+				 FilterOperatorUtil._mOperators.firstDayMonth,
+				 FilterOperatorUtil._mOperators.lastDayMonth,
+				 FilterOperatorUtil._mOperators.firstDayQuarter,
+				 FilterOperatorUtil._mOperators.lastDayQuarter,
+				 FilterOperatorUtil._mOperators.firstDayYear,
+				 FilterOperatorUtil._mOperators.lastDayYear,
+				 FilterOperatorUtil._mOperators.todayFromTo,
+				 FilterOperatorUtil._mOperators.lastDays,
+				 FilterOperatorUtil._mOperators.nextDays,
+
+				 FilterOperatorUtil._mOperators.thisWeek,
+				 FilterOperatorUtil._mOperators.lastWeek,
+				 FilterOperatorUtil._mOperators.lastWeeks,
+				 FilterOperatorUtil._mOperators.nextWeek,
+				 FilterOperatorUtil._mOperators.nextWeeks,
+
+				 FilterOperatorUtil._mOperators.specificMonth,
+				 FilterOperatorUtil._mOperators.specificMonthInYear,
+				 FilterOperatorUtil._mOperators.thisMonth,
+				 FilterOperatorUtil._mOperators.lastMonth,
+				 FilterOperatorUtil._mOperators.lastMonths,
+				 FilterOperatorUtil._mOperators.nextMonth,
+				 FilterOperatorUtil._mOperators.nextMonths,
+
+				 FilterOperatorUtil._mOperators.thisQuarter,
+				 FilterOperatorUtil._mOperators.lastQuarter,
+				 FilterOperatorUtil._mOperators.lastQuarters,
+				 FilterOperatorUtil._mOperators.nextQuarter,
+				 FilterOperatorUtil._mOperators.nextQuarters,
+
+				 FilterOperatorUtil._mOperators.quarter1,
+				 FilterOperatorUtil._mOperators.quarter2,
+				 FilterOperatorUtil._mOperators.quarter3,
+				 FilterOperatorUtil._mOperators.quarter4,
+
+				 FilterOperatorUtil._mOperators.thisYear,
+				 FilterOperatorUtil._mOperators.lastYear,
+				 FilterOperatorUtil._mOperators.lastYears,
+				 FilterOperatorUtil._mOperators.nextYear,
+				 FilterOperatorUtil._mOperators.nextYears,
+
+				 FilterOperatorUtil._mOperators.yearToDate,
+				 FilterOperatorUtil._mOperators.dateToYear
 				]
 		);
 		FilterOperatorUtil.setOperatorsForType(

package/src/sap/ui/mdc/condition/Operator.js

@@ -46,6 +46,7 @@ sap.ui.define([
 		 * @extends sap.ui.base.Object
 		 * @param {object} oConfiguration Properties of the operator
 		 * @param {string} oConfiguration.name Name of the operator used in the condition
+		 * @param {object} [oConfiguration.alias] Alias names based on <code>BaseType</code>, used to map to <code>DynamicDateOption</code> if <code>DynamicDateRange</code> is used
 		 * @param {string} oConfiguration.filterOperator The operator's default filter operator that is created as defined in {@link sap.ui.model.FilterOperator FilterOperator}
 		 * @param {string} oConfiguration.tokenParse The string representation of the regular expression that is used by the operator to parse a value
 		 *                 to eliminate the operator and get the data string. A placeholder that refers to the translated tokenText can be used. <code>#tokenText#</code> refers to the
@@ -83,7 +84,7 @@ sap.ui.define([
 		 * @param {string} [oConfiguration.additionalInfo] additionalInfo text for the operator. Will be shown in the operator suggest as second column. If not used (undefined) the Include or Exclude information of the operator is used.
 		 * @constructor
 		 * @author SAP SE
-		 * @version 1.99.1
+		 * @version 1.102.0
 		 * @private
 		 * @ui5-restricted sap.fe
 		 * @MDC_PUBLIC_CANDIDATE
@@ -287,11 +288,12 @@ sap.ui.define([
 		 * @param {string} sFieldPath Path of filter
 		 * @param {sap.ui.model.Type} oType Data type of the used filter field
 		 * @param {boolean} [bCaseSensitive] creates a caseSensitive filter
+		 * @param {sap.ui.mdc.enum.BaseType} [sBaseType] Basic type
 		 * @returns {sap.ui.model.Filter} filter object
 		 * @private
 		 * @ui5-restricted sap.ui.mdc
 		 */
-		Operator.prototype.getModelFilter = function(oCondition, sFieldPath, oType, bCaseSensitive) {
+		Operator.prototype.getModelFilter = function(oCondition, sFieldPath, oType, bCaseSensitive, sBaseType) {
 
 			var vValue = oCondition.values[0];
 			var oFilter;
@@ -378,15 +380,16 @@ sap.ui.define([
 		 *
 		 * @param {sap.ui.mdc.condition.ConditionObject} oCondition Condition
 		 * @param {sap.ui.model.Type} [oType] Data type
-		 * @param {string} [sDisplay] Display mode
+		 * @param {sap.ui.mdc.enum.FieldDisplay} [sDisplay] Display mode
 		 * @param {boolean} [bHideOperator=false] If set, only the value output is returned without any visible operator
+		 * @param {sap.ui.model.Type[]} [aCompositeTypes] additional Types used for parts of a <code>CompositeType</code>
 		 * @returns {string} formatted text
 		 * @throws {sap.ui.model.FormatException} if the values cannot be formatted
 		 *
 		 * @private
 		 * @ui5-restricted sap.ui.mdc
 		 */
-		Operator.prototype.format = function(oCondition, oType, sDisplay, bHideOperator) { // sDisplay needed in EQ formatter
+		Operator.prototype.format = function(oCondition, oType, sDisplay, bHideOperator, aCompositeTypes) { // sDisplay needed in EQ formatter
 
 			var aValues = oCondition.values;
 			var iCount = this.valueTypes.length;
@@ -400,7 +403,7 @@ sap.ui.define([
 					if (vValue === undefined || vValue === null) {
 						vValue = oType ? oType.parseValue("", "string") : ""; // for empty value use initial value of type
 					}
-					var sReplace = oType ? oType.formatValue(vValue, "string") : vValue;
+					var sReplace = this._formatValue(vValue, oType, aCompositeTypes);
 					// the regexp will replace placeholder like $0, 0$ and {0}
 					sTokenText = sTokenText.replace(new RegExp("\\$" + i + "|" + i + "\\$" + "|" + "\\{" + i + "\\}", "g"), sReplace);
 				}
@@ -409,6 +412,45 @@ sap.ui.define([
 
 		};
 
+		/**
+		 * Formats a value using the data type.
+		 *
+		 * if a <code>CompositeType is used</code> and it needs internal values, the corresponding data types are used to provide these values.
+		 *
+		 * @param {any} vValue value
+		 * @param {sap.ui.model.Type} [oType] Data type
+		 * @param {sap.ui.model.Type[]} [aCompositeTypes] additional Types used for parts of a <code>CompositeType</code>
+		 * @returns {string} formatted text
+		 * @throws {sap.ui.model.FormatException} if the values cannot be formatted
+		 *
+		 * @private
+		 * @ui5-restricted sap.ui.mdc
+		 */
+		Operator.prototype._formatValue = function(vValue, oType, aCompositeTypes) {
+
+			var sText;
+
+			if (oType) {
+				if (oType.isA("sap.ui.model.CompositeType") && oType.getUseInternalValues() && Array.isArray(vValue) && aCompositeTypes) {
+					vValue = merge([], vValue); // use copy to not change original array
+					for (var i = 0; i < vValue.length; i++) {
+						if (aCompositeTypes[i]) {
+							var oFormat = aCompositeTypes[i].getModelFormat();
+							if (oFormat && typeof oFormat.parse === "function") {
+								vValue[i] = oFormat.parse(vValue[i]);
+							}
+						}
+					}
+				}
+				sText = oType.formatValue(vValue, "string");
+			} else {
+				sText = vValue;
+			}
+
+			return sText;
+
+		};
+
 		/**
 		 * Parses a text.
 		 *
@@ -416,13 +458,14 @@ sap.ui.define([
 		 * @param {sap.ui.model.Type} oType Data type
 		 * @param {sap.ui.mdc.enum.FieldDisplay} sDisplayFormat Display format
 		 * @param {boolean} bDefaultOperator If true, operator is used as default. In this case parsing without operator also works
+		 * @param {sap.ui.model.Type[]} [aCompositeTypes] additional Types used for parts of a <code>CompositeType</code>
 		 * @returns {any[]} array of values
 		 * @throws {sap.ui.model.ParseException} if the text cannot be parsed
 		 *
 		 * @private
 		 * @ui5-restricted sap.ui.mdc
 		 */
-		Operator.prototype.parse = function(sText, oType, sDisplayFormat, bDefaultOperator) {
+		Operator.prototype.parse = function(sText, oType, sDisplayFormat, bDefaultOperator, aCompositeTypes) {
 
 			var aValues = this.getValues(sText, sDisplayFormat, bDefaultOperator);
 			var aResult; // might remain undefined - if no match
@@ -436,7 +479,7 @@ sap.ui.define([
 						if (this.valueTypes[i] !== Operator.ValueType.Static) {
 							var vValue;
 							if (this.valueTypes[i]) {
-								vValue = this._parseValue(aValues[i], oType);
+								vValue = this._parseValue(aValues[i], oType, aCompositeTypes);
 							} else {
 								vValue = aValues[i]; // Description -> just take value
 							}
@@ -459,13 +502,14 @@ sap.ui.define([
 		 *
 		 * @param {string} sValue Text
 		 * @param {sap.ui.model.Type} oType Data type
+		 * @param {sap.ui.model.Type[]} [aCompositeTypes] additional Types used for parts of a <code>CompositeType</code>
 		 * @returns {string} single value
 		 * @throws {sap.ui.model.ParseException} if the text cannot be parsed
 		 *
 		 * @private
-		 * @ui5-restricted Operator subclasses
+		 * @ui5-restricted sap.ui.mdc
 		 */
-		Operator.prototype._parseValue = function(sValue, oType) { // needed in EQ operator to be accessed from outside
+		Operator.prototype._parseValue = function(sValue, oType, aCompositeTypes) { // needed in EQ operator to be accessed from outside
 
 			if (sValue === undefined) {
 				return sValue; // as some types running in errors with undefined and in this case there is nothing to parse
@@ -478,12 +522,19 @@ sap.ui.define([
 
 			var vValue = oType ? oType.parseValue(sValue, "string", aCurrentValue) : sValue;
 
-			if (oType && oType._aCurrentValue && Array.isArray(vValue)) {
+			if (oType && oType.isA("sap.ui.model.CompositeType") && Array.isArray(vValue) && (oType._aCurrentValue || (oType.getUseInternalValues() && aCompositeTypes))) {
 				// in case the user only entered a part of the CompositeType, we add the missing parts from aCurrentValue
 				// but add only the parts that have entries in array after parsing ( not set one-time parts)
-				for (var j = 0; j < vValue.length; j++) {
-					if (vValue[j] === undefined) {
-						vValue[j] = oType._aCurrentValue[j] === undefined ? null : oType._aCurrentValue[j]; // undefined not valid for formatting, needs to be null
+				for (var i = 0; i < vValue.length; i++) {
+					if (vValue[i] === undefined && oType._aCurrentValue) {
+						vValue[i] = oType._aCurrentValue[i] === undefined ? null : oType._aCurrentValue[i]; // undefined in CompositeType means "not changed" -> if no current value it needs to be null
+						// value in aCurrentValues is already in model-format, so it need not to be formatted again
+					} else if (oType.getUseInternalValues() && aCompositeTypes && aCompositeTypes[i]) {
+						// convert result into model-format
+						var oFormat = aCompositeTypes[i].getModelFormat();
+						if (oFormat && typeof oFormat.format === "function") {
+							vValue[i] = oFormat.format(vValue[i]);
+						}
 					}
 				}
 			}
@@ -497,12 +548,13 @@ sap.ui.define([
 		 *
 		 * @param {any} aValues Values
 		 * @param {sap.ui.model.Type} oType Data type
+		 * @param {sap.ui.model.Type[]} [aCompositeTypes] additional Types used for parts of a <code>CompositeType</code>
 		 * @throws {sap.ui.model.ValidateException} if the values are invalid
 		 *
 		 * @private
 		 * @ui5-restricted sap.ui.mdc
 		 */
-		Operator.prototype.validate = function(aValues, oType) {
+		Operator.prototype.validate = function(aValues, oType, aCompositeTypes) {
 
 			var iCount = this.valueTypes.length;
 
@@ -519,6 +571,25 @@ sap.ui.define([
 						if (vValue === undefined || vValue === null) {
 							vValue = oType ? oType.parseValue("", "string") : ""; // for empty value use initial value of type
 						}
+
+						if (oType.isA("sap.ui.model.CompositeType") && Array.isArray(vValue) && aCompositeTypes) {
+							// validate for basic types too
+							vValue = merge([], vValue); // use copy to not change original array
+							for (var j = 0; j < vValue.length; j++) {
+								if (aCompositeTypes[j]) {
+									aCompositeTypes[j].validateValue(vValue[j]);
+
+									if (oType.getUseInternalValues()) {
+										// use internal format for validation on CompositeType
+										var oFormat = aCompositeTypes[j].getModelFormat();
+										if (oFormat && typeof oFormat.parse === "function") {
+											vValue[j] = oFormat.parse(vValue[j]);
+										}
+									}
+								}
+							}
+						}
+
 						oType.validateValue(vValue);
 					}
 				}
@@ -655,16 +726,17 @@ sap.ui.define([
 		 * @param {sap.ui.model.Type} oType Data type
 		 * @param {sap.ui.mdc.enum.FieldDisplay} sDisplayFormat Display format
 		 * @param {boolean} bDefaultOperator If true, operator is used as default. In this case parsing without operator also works
+		 * @param {sap.ui.model.Type[]} [aCompositeTypes] additional Types used for parts of a <code>CompositeType</code>
 		 * @returns {sap.ui.mdc.condition.ConditionObject} The condition for the text
 		 * @throws {sap.ui.model.ParseException} if the text cannot be parsed
 		 *
 		 * @private
 		 * @ui5-restricted sap.ui.mdc
 		 */
-		Operator.prototype.getCondition = function(sText, oType, sDisplayFormat, bDefaultOperator) {
+		Operator.prototype.getCondition = function(sText, oType, sDisplayFormat, bDefaultOperator, aCompositeTypes) {
 
 			if (this.test(sText) || (bDefaultOperator && sText && this.hasRequiredValues())) {
-				var aValues = this.parse(sText, oType, sDisplayFormat, bDefaultOperator);
+				var aValues = this.parse(sText, oType, sDisplayFormat, bDefaultOperator, aCompositeTypes);
 				if (aValues.length == this.valueTypes.length || this.valueTypes[0] === Operator.ValueType.Static
 						|| (aValues.length === 1 && this.valueTypes.length === 2 && !this.valueTypes[1])) { // EQ also valid without description
 					var oCondition =  Condition.createCondition( this.name, aValues );
@@ -742,6 +814,7 @@ sap.ui.define([
 		 *
 		 * @param {sap.ui.mdc.condition.ConditionObject} oCondition1 Condition to check
 		 * @param {sap.ui.mdc.condition.ConditionObject} oCondition2 Condition to check
+
 		 * @returns {boolean} <code>true</code> if conditions are equal
 		 * @private
 		 * @ui5-restricted sap.ui.mdc
@@ -755,6 +828,9 @@ sap.ui.define([
 				var oCheckValue1 = this.getCheckValue(oCondition1);
 				var oCheckValue2 = this.getCheckValue(oCondition2);
 
+
+				// In/outParameter logic still used as long as old FiledValueHelp is supported
+				// Also may exist in older variants
 				if (oCondition1.inParameters && oCondition2.inParameters) {
 					// TODO: also compare in-parameters (but only of set on both)
 					oCheckValue1.inParameters = oCondition1.inParameters;
@@ -766,6 +842,12 @@ sap.ui.define([
 					oCheckValue2.outParameters = oCondition2.outParameters;
 				}
 
+				if (oCondition1.payload && oCondition2.payload) {
+					// TODO: check payload also if only set on one condition?
+					oCheckValue1.payload = oCondition1.payload;
+					oCheckValue2.payload = oCondition2.payload;
+				}
+
 				if (oCondition1.validated && oCondition2.validated) {
 					// also compare validated (but only of set on both)
 					oCheckValue1.validated = oCondition1.validated;