@openui5/sap.ui.mdc 1.96.5 → 1.99.0

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

@@ -0,0 +1,437 @@
+/*!
+ * OpenUI5
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+sap.ui.define([
+	'sap/m/DynamicDateOption',
+	'sap/m/DynamicDateValueHelpUIType',
+	'sap/m/Input',
+	'sap/m/DatePicker',
+	'sap/ui/mdc/condition/Operator',
+	'sap/ui/mdc/util/DateUtil',
+	'sap/ui/model/json/JSONModel',
+	'sap/ui/model/FormatException',
+	'sap/ui/model/ParseException',
+	'sap/ui/model/ValidateException',
+	'sap/ui/core/library'
+], function(
+		DynamicDateOption,
+		DynamicDateValueHelpUIType,
+		Input,
+		DatePicker,
+		Operator,
+		DateUtil,
+		JSONModel,
+		FormatException,
+		ParseException,
+		ValidateException,
+		coreLibrary
+	) {
+		"use strict";
+
+		var ValueState = coreLibrary.ValueState;
+
+		/**
+		 * Constructor for a new OperatorDynamicDateOption.
+		 *
+		 * @param {string} [sId] ID for the new control, generated automatically if no ID is given
+		 * @param {object} [mSettings] Initial settings for the new control
+		 * @param {string} [mSettings.key] One of the predefined keys identifying the standard dynamic date
+		 *
+		 * @class
+		 * Maps an {@link sap.ui.mdc.condition.Operator Operator} to a {@link sap.m.DynamicDateOption DynamicDateOption}.
+		 * @extends sap.m.DynamicDateOption
+		 *
+		 * @author SAP SE
+		 * @version 1.99.0
+		 *
+		 * @private
+		 * @ui5-restricted sap.ui.mdc
+		 * @experimental As of version 1.96
+		 * @since 1.96
+		 * @alias sap.ui.mdc.condition.OperatorDynamicDateOption
+		 * @ui5-metamodel This control/element also will be described in the UI5 (legacy) designtime metamodel
+		 */
+		var OperatorDynamicDateOption = DynamicDateOption.extend("sap.ui.mdc.condition.OperatorDynamicDateOption", /** @lends sap.ui.mdc.condition.OperatorDynamicDateOption.prototype */ {
+			metadata: {
+				library: "sap.ui.mdc",
+				properties: {
+					/**
+					 * Operator used in the corresponding filter field.
+					 *
+					 * <b>Note:</b> A condition must be an instance of {@link sap.ui.mdc.condition.Operator Operator}.
+					 */
+					operator: { type: "object" },
+					/**
+					 * Data type of the corresponding filter field.
+					 *
+					 * <b>Note:</b> A condition must  be an instance of {@link sap.ui.model.Type Type}.
+					 */
+					type: { type: "object" }
+				}
+			}
+		});
+
+		OperatorDynamicDateOption.prototype.exit = function() {
+			if (this._oModel) {
+				this._oModel.destroy();
+				this._oModel = undefined;
+				this._mChangeHandler = undefined;
+			}
+
+			if (this._aUITypes) {
+				for (var i = 0; i < this._aUITypes.length; i++) {
+					this._aUITypes[i].destroy();
+				}
+				this._aUITypes = undefined;
+			}
+			// _removeControls.call(this);
+		};
+
+		OperatorDynamicDateOption.prototype.validateProperty = function(sPropertyName, oValue) {
+
+			if (sPropertyName === "operator" && oValue && (typeof oValue !== "object" || !oValue.isA || !oValue.isA("sap.ui.mdc.condition.Operator"))) {
+				throw new Error("\"" + oValue + "\" is of type " + typeof oValue + ", expected " +
+						"sap.ui.mdc.condition.Operator for property \"" + sPropertyName + "\" of " + this);
+			} else if (sPropertyName === "type" && oValue && (typeof oValue !== "object" || !oValue.isA || !oValue.isA("sap.ui.model.Type"))) {
+				throw new Error("\"" + oValue + "\" is of type " + typeof oValue + ", expected " +
+						"sap.ui.model.Type for property \"" + sPropertyName + "\" of " + this);
+			}
+
+			return DynamicDateOption.prototype.validateProperty.apply(this, arguments);
+
+		};
+
+		OperatorDynamicDateOption.prototype.getKey = function() {
+
+			var oOperator = this.getOperator();
+			return oOperator.name;
+
+		};
+
+		OperatorDynamicDateOption.prototype.isRange = function() {
+
+			var oOperator = this.getOperator();
+			return oOperator.isA("sap.ui.mdc.condition.RangeOperator");
+
+		};
+
+		OperatorDynamicDateOption.prototype.getText = function(oControl) {
+
+			var oOperator = this.getOperator();
+			return oOperator.longText;
+
+		};
+
+		OperatorDynamicDateOption.prototype.getValueHelpUITypes = function(oControl) {
+
+			if (!this._aUITypes) {
+				var oOperator = this.getOperator();
+				var oType = this.getType();
+				this._aUITypes = [];
+
+				for (var i = 0; i < oOperator.valueTypes.length; i++) {
+					var vType = oOperator.valueTypes[i];
+					if (vType === Operator.ValueType.Self) {
+						this._aUITypes.push(new DynamicDateValueHelpUIType({
+							type: "date"
+						}));
+					} else if (vType === Operator.ValueType.Static) {
+						continue;
+					} else {
+						oType = oOperator._createLocalType(vType, oType);
+						if (oType.isA("sap.ui.model.type.Integer") || oType.isA("sap.ui.model.odata.type.Int")) { // TODO: better check for Integer
+							this._aUITypes.push(new DynamicDateValueHelpUIType({
+								type: "int"
+							}));
+						} else {
+							this._aUITypes.push(new DynamicDateValueHelpUIType({
+								type: "custom"
+							}));
+						}
+					}
+				}
+			}
+
+			return this._aUITypes;
+
+		};
+
+		OperatorDynamicDateOption.prototype.createValueHelpUI = function(oControl, fnControlsUpdated) {
+			var oValue = oControl.getValue();
+			var oOperator = this.getOperator();
+			var oType = this.getType();
+			var sKey = this.getKey();
+			var sControlId = oControl.getId();
+
+			if (!oValue || oValue.operator !== sKey) {
+				// initialize value
+				oValue = {operator: sKey, values: []};
+				if (oOperator.valueDefaults) {
+					oValue.values = oOperator.valueDefaults;
+				}
+			}
+
+			// remove old controls as they are destroyed after usage from DynamicDateRange control
+			_removeControls.call(this, oControl);
+			if (!oControl.aControlsByParameters) {
+				oControl.aControlsByParameters = {};
+			}
+			oControl.aControlsByParameters[sKey] = [];
+
+			var fnChangeHandler = function(oEvent) {
+				fnControlsUpdated(this);
+			}.bind(this);
+
+			for (var i = 0; i < oOperator.valueTypes.length; i++) {
+				var vType = oOperator.valueTypes[i];
+				var oDate;
+
+				if (!oControl.aControlsByParameters[sKey][i]) {
+					if (oOperator.createControl) {
+						// use internal model to bind the control
+						if (!this._oModel) {
+							fnChangeHandler = function(oEvent) {
+								var sPath = oEvent.getParameter("path");
+								var aParts = sPath.split("/");
+								var sControlId = aParts[0] || aParts[1];
+								if (this._mChangeHandler && this._mChangeHandler[sControlId]) {
+									this._mChangeHandler[sControlId](this);
+								}
+							}.bind(this);
+							this._oModel = new JSONModel();
+							this._oModel.attachPropertyChange({}, fnChangeHandler, this);
+							this._mChangeHandler = {};
+						}
+						var oModelData = this._oModel.getData();
+						oModelData[sControlId] = { // only change for current control
+							value0: oValue && oValue.values[0],
+							value1: oValue && oValue.values[1]
+						};
+						this._mChangeHandler[sControlId] = fnControlsUpdated;
+						if (vType !== Operator.ValueType.Self) {
+							oType = oOperator._createLocalType(vType, oType);
+						}
+						var oInputControl = oOperator.createControl(oType, "internal>/" + sControlId + "/value" + i, i, sControlId + "-" + i);
+						oInputControl.setModel(this._oModel, "internal");
+						oControl.aControlsByParameters[sKey].push(oInputControl);
+					} else if (vType === Operator.ValueType.Self) {
+						// TODO: DatePicker or Calendar?
+						// convert internal value to date
+						if (oValue && oValue.values[i]) {
+							oDate = DateUtil.typeToUniversalDate(oValue.values[i], oType);
+							oDate = DateUtil.utcToLocal(oDate);
+						}
+						var oFormatOptions = oType.getFormatOptions();
+
+						var oDatePicker = new DatePicker(sControlId + "-" + i, {
+							dateValue: oDate,
+							displayFormat: oFormatOptions.style || oFormatOptions.pattern,
+							displayFormatType: oFormatOptions.calendarType,
+							change: fnChangeHandler
+						});
+						oControl.aControlsByParameters[sKey].push(oDatePicker);
+					} else if (typeof vType === "object"){
+						// just use Input
+						var oInput = new Input(sControlId + "-" + i, {
+							value: oValue && oValue.values[i],
+							change: fnChangeHandler
+						});
+						oControl.aControlsByParameters[sKey].push(oInput);
+					}
+				// } else 					// update values
+				// 	if (oOperator.createControl) {
+				// 		this._oModel.setProperty("/value0", oValue && oValue.values[0]);
+				// 		this._oModel.setProperty("/value1", oValue && oValue.values[1]);
+				// 	} else if (vType === Operator.ValueType.Self) {
+				// 		if (oValue && oValue.values[i]) {
+				// 			oDate = DateUtil.typeToUniversalDate(oValue.values[i], oType);
+				// 			oDate = DateUtil.utcToLocal(oDate);
+				// 		}
+				// 		oControl.aControlsByParameters[sKey][i].setDateValue(oDate);
+				// 	} else  if (typeof vType === "object"){
+				// 		oControl.aControlsByParameters[sKey][i].setValue(oValue && oValue.values[i]);
+					}
+
+			}
+
+			return oControl.aControlsByParameters[sKey];
+
+		};
+
+		OperatorDynamicDateOption.prototype.validateValueHelpUI = function(oControl) {
+
+			var sKey = this.getKey();
+			var oOperator = this.getOperator();
+			var oType = this.getType();
+			var oOutput;
+			var bValid = true;
+			var sValueState = ValueState.None;
+			var sValueStateText;
+			var i = 0;
+
+			try {
+				oOutput = this.getValueHelpOutput(oControl); // catch ParseExeptions
+				for (i = 0; i < oOutput.values.length; i++) {
+					var vValue = oOutput.values[i];
+					if (vValue === undefined || vValue === null) { // TODO: might be operator dependent
+						bValid = false;
+					}
+				}
+				oOperator.validate(oOutput.values, oType);
+			} catch (oException) {
+				bValid = false;
+				sValueState = ValueState.Error;
+				sValueStateText = oException.message;
+				if (oException && !(oException instanceof ParseException) && !(oException instanceof ValidateException)) {
+					throw oException; // unknown error -> just raise it
+				}
+			}
+
+			if (!oOperator.createControl) {
+				// custom control is bound, so input is checked in binding
+				for (i = 0; i < oControl.aControlsByParameters[sKey].length; i++) {
+					var oInputControl = oControl.aControlsByParameters[sKey][i];
+					if (oInputControl.setValueState) {
+						oInputControl.setValueState(sValueState);
+						oInputControl.setValueStateText(sValueStateText);
+					}
+				}
+			}
+
+			return bValid;
+
+		};
+
+		OperatorDynamicDateOption.prototype.getValueHelpOutput = function(oControl) {
+
+			var sKey = this.getKey();
+			var oResult = {operator: sKey, values: []};
+			var oOperator = this.getOperator();
+			var oType = this.getType();
+			var sControlId = oControl.getId();
+
+			for (var i = 0; i < oOperator.valueTypes.length; i++) {
+				var oInputControl = oControl.aControlsByParameters[sKey][i];
+				if (oInputControl) {
+					var vValue;
+					if (oOperator.createControl) {
+						// use value from internal Model
+						vValue = this._oModel ? this._oModel.getProperty("/" + sControlId + "/value" + i) : null;
+					} else if (oOperator.valueTypes[i] === Operator.ValueType.Self) {
+						// DatePicker used -> get Date Value
+						if (!oInputControl.isValidValue()) {
+							throw new ParseException(); // to show error state
+						}
+						vValue = oInputControl.getDateValue();
+						if (vValue) {
+							// parse to Types format
+							vValue = DateUtil.localToUtc(vValue);
+							vValue = DateUtil.universalDateToType(vValue, oType);
+						}
+					} else {
+						vValue = oInputControl.getValue();
+						oType = oOperator._createLocalType(oOperator.valueTypes[i], oType);
+						// parse String to types value
+						vValue = oType.parseValue(vValue, "string");
+					}
+					oResult.values.push(vValue);
+				}
+			}
+
+			return oResult;
+
+		};
+
+		OperatorDynamicDateOption.prototype.getGroupHeader = function() {
+			var oOperator = this.getOperator();
+			if (oOperator.group && oOperator.group.text) {
+				return oOperator.group.text;
+			}
+
+			return DynamicDateOption.prototype.getGroupHeader.apply(this, arguments); // "Default group header still used!"; //TODO how to create a custom Option inside an existing group?
+		};
+
+		OperatorDynamicDateOption.prototype.getGroup = function() {
+			var oOperator = this.getOperator();
+			if (oOperator.group) {
+				return oOperator.group.id;
+			}
+			return DynamicDateOption.prototype.getGroup.apply(this, arguments);
+		};
+
+		OperatorDynamicDateOption.prototype.toDates = function(oValue) {
+			var oOperator = this.getOperator();
+			var oType = this.getType();
+			var aRange;
+			var i = 0;
+
+			if (oOperator.isA("sap.ui.mdc.condition.RangeOperator")) {
+				aRange = oOperator._getRange(oValue && oValue.values, oType);
+				// convert to local date
+				for (i = 0; i < aRange.length; i++) {
+					aRange[i] = DateUtil.typeToUniversalDate(aRange[i], oType);
+					aRange[i] = DateUtil.utcToLocal(aRange[i]);
+				}
+			} else if (oOperator.valueTypes[0] === Operator.ValueType.Self) {
+				aRange = oValue.values;
+				for (i = 0; i < aRange.length; i++) {
+					if (aRange[i]) {
+						aRange[i] = DateUtil.typeToUniversalDate(aRange[i], oType);
+						aRange[i] = DateUtil.utcToLocal(aRange[i]);
+					}
+				}
+				if (aRange.length === 1) {
+					// TODO: better solution for single dates
+					aRange.push(aRange[0]);
+				}
+				// TODO How to convert GT or GE.....
+			} else if ([Operator.ValueType.Self, Operator.ValueType.Static].indexOf(oOperator.valueTypes[0]) === -1) {
+				// oType = oOperator._createLocalType(oOperator.valueTypes[0], this.type);
+				throw new Error("Cannot convert to date, use RangeOperator");
+			}
+			return aRange;
+		};
+
+		OperatorDynamicDateOption.prototype.format = function(oValue) {
+			var oOperator = this.getOperator();
+			var oType = this.getType();
+			return oOperator.format(oValue, oType);
+		};
+
+		OperatorDynamicDateOption.prototype.parse = function(sValue) {
+			var oOperator = this.getOperator();
+			var oType = this.getType();
+
+			if (sValue && oOperator.parse(sValue)) {
+				var oResult = {};
+				oResult.operator = this.getKey();
+				oResult.values = oOperator.parse(sValue, oType);
+				return oResult;
+			}
+		};
+
+		OperatorDynamicDateOption.prototype.enhanceFormattedValue = function(sFormattedValue, sAdditionalValue) {
+			return false;
+		};
+
+		function _removeControls(oControl) {
+
+			var sKey = this.getKey();
+
+			if (oControl && oControl.aControlsByParameters && oControl.aControlsByParameters[sKey]) {
+				for (var i = 0; i < oControl.aControlsByParameters[sKey].length; i++) {
+					var oUIControl = oControl.aControlsByParameters[sKey][i];
+					if (!oUIControl.bIsDestroyed) {
+						oUIControl.destroy();
+					}
+				}
+				delete oControl.aControlsByParameters[sKey];
+			}
+
+		}
+
+		return OperatorDynamicDateOption;
+	});

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

@@ -33,7 +33,7 @@ sap.ui.define([
 		 * @param {int[]|function} [oConfiguration.defaultValues] Array of values for the defaults of <code>RangeOperators</code> parameter. This can be a function, which returns the array of values. If not used the default for the values is 1.
 		 * @constructor
 		 * @author SAP SE
-		 * @version 1.96.5
+		 * @version 1.99.0
 		 * @private
 		 * @ui5-restricted sap.fe
 		 * @MDC_PUBLIC_CANDIDATE

package/src/sap/ui/mdc/designtime/chart/Chart.designtime.js

@@ -4,15 +4,90 @@
  * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
  */
 sap.ui.define([
-
-], function () {
+	"sap/ui/mdc/p13n/Engine"
+	], function (Engine) {
 	"use strict";
 
 	return {
-		name: "{name}",
-		description: "{description}",
 		actions: {
-            //TBD: keyuser support
+			settings: function () {
+				//RTA expects the settings to be returned as function
+				return {
+					handler: function (oControl, mPropertyBag) {
+						return Engine.getInstance().getRTASettingsActionHandler(oControl, mPropertyBag, oControl.getP13nMode());
+					}
+				};
+			}
+		},
+		properties: {
+			width: {
+				ignore: true
+			},
+			height: {
+				ignore: true
+			},
+			delegate: {
+				ignore: true
+			},
+			header: {
+				ignore: true
+			},
+			noDataText: {
+				ignore: true
+			},
+			p13nMode: {
+				ignore: true
+			},
+			legendVisible: {
+				ignore: true
+			},
+			ignoreToolbarActions: {
+				ignore: true
+			},
+			minWidth: {
+				ignore: true
+			},
+			minHeight: {
+				ignore: true
+			},
+			sortConditions: {
+				ignore: true
+			},
+			filterConditions: {
+				ignore: true
+			},
+			showChartTooltip: {
+				ignore: true
+			},
+			autoBindOnInit: {
+				ignore: true
+			},
+			chartType: {
+				ignore: true
+			},
+			showSelectionDetails: {
+				ignore: true
+			}
+		},
+		aggregations: {
+			items: {
+				ignore: true
+			},
+			actions: {
+				ignore: true
+			},
+			selectionDetailsActions: {
+				ignore: true
+			},
+			_toolbar: {
+				ignore: false
+			},
+			_breadcrumbs: {
+				ignore: true
+			},
+			_innerChart: {
+				ignore: true
+			}
 		}
 	};
 

package/src/sap/ui/mdc/designtime/field/Field.designtime.js

@@ -0,0 +1,97 @@
+/*
+ * ! OpenUI5
+ * (c) Copyright 2009-2022 SAP SE or an SAP affiliate company.
+ * Licensed under the Apache License, Version 2.0 - see LICENSE.txt.
+ */
+
+sap.ui.define(['sap/ui/fl/Utils', 'sap/ui/fl/apply/api/FlexRuntimeInfoAPI'], function(Utils, FlexRuntimeInfoAPI) {
+	"use strict";
+
+    var oResourceBundle = sap.ui.getCore().getLibraryResourceBundle("sap.ui.mdc");
+
+	return {
+        properties: {
+			value: {
+				ignore: true
+			},
+
+			additionalValue: {
+				ignore: true
+			}
+		},
+        getStableElements: function(oField) {
+            if (!oField.getFieldInfo()) {
+                return [];
+            }
+            var oFieldInfo = oField.getFieldInfo();
+            var oControl = typeof oFieldInfo.getSourceControl() === "string" ? sap.ui.getCore().byId(oFieldInfo.getSourceControl()) : oFieldInfo.getSourceControl();
+            if (!oControl) {
+                oControl = oField;
+            }
+            var oAppComponent = Utils.getAppComponentForControl(oControl) || Utils.getAppComponentForControl(oField);
+            var sStableID = oFieldInfo._createPanelId(Utils, FlexRuntimeInfoAPI);
+
+			return [
+                {
+                    id: sStableID,
+                    appComponent: oAppComponent
+                }
+            ];
+		},
+        actions: {
+            settings: function(oField) {
+                if (!oField.getFieldInfo()) {
+                    return {};
+                }
+
+                return {
+                    name: oResourceBundle.getText("info.POPOVER_DEFINE_LINKS"),
+                    handler: function (oControl, mPropertyBag) {
+                        var oFieldInfo = oControl.getFieldInfo();
+                        return oFieldInfo.getContent().then(function(oPanel) {
+                            oFieldInfo.addDependent(oPanel);
+                            // wait for createItem changes
+                            return FlexRuntimeInfoAPI.waitForChanges({
+                                element: oPanel
+                            }).then(function() {
+                                var oEngine = sap.ui.mdc.p13n.Engine.getInstance();
+                                mPropertyBag.fnAfterClose = function() {
+                                    oPanel.destroy();
+                                };
+                                var fnGetChanges = function() {
+                                    return oEngine.getRTASettingsActionHandler(oPanel, mPropertyBag, "LinkItems").then(function(aChanges) {
+                                        aChanges.forEach(function(oChange) {
+                                            var oSelectorElement = oChange.selectorElement;
+                                            delete oChange.selectorElement;
+
+                                            var oAppComponent = Utils.getAppComponentForControl(oControl) || Utils.getAppComponentForControl(oField);
+                                            oChange.selectorControl = {
+                                                id: oSelectorElement.getId(),
+                                                controlType: oSelectorElement === oPanel ? "sap.ui.mdc.link.Panel" : "sap.ui.mdc.link.PanelItem",
+                                                appComponent: oAppComponent
+                                            };
+                                        });
+                                        return aChanges;
+                                    });
+                                };
+                                var aPanelItems = oPanel.getItems();
+
+                                if (aPanelItems.length > 0) {
+                                    // wait for hideItem / revealItem changes
+                                    return FlexRuntimeInfoAPI.waitForChanges({
+                                        selectors: aPanelItems
+                                    }).then(function() {
+                                        return fnGetChanges();
+                                    });
+                                } else {
+                                    return fnGetChanges();
+                                }
+                            });
+                        });
+                    },
+                    CAUTION_variantIndependent: true
+                };
+            }
+        }
+    };
+});