@sapui5/sap.fe.core 1.100.0 → 1.102.0

package/src/sap/fe/core/controls/massEdit/MassEditHandlers.js

@@ -2,30 +2,535 @@
  * SAP UI development toolkit for HTML5 (SAPUI5)
  *      (c) Copyright 2009-2021 SAP SE. All rights reserved
  */
-sap.ui.define([], function () {
+sap.ui.define(["sap/base/Log", "sap/fe/core/helpers/ModelHelper", "sap/fe/macros/internal/valuehelp/ValueListHelper", "sap/ui/core/Core"], function (Log, ModelHelper, ValueListHelper, Core) {
   "use strict";
 
-  /**
-   * Constructor for a new Visual Filter Container.
-   * Used for visual filters
-   *
-   * @param {string} [sId] ID for the new control, generated automatically if no ID is given
-   * @extends sap.ui.mdc.filterbar.IFilterContainer
-   * @class
-   * @private
-   * @alias sap.fe.core.controls.filterbar.VisualFilterContainer
-   */
   var MassEditHandlers = {
-    handleMassEditChange: function (oEvent) {
-      var oSource = oEvent && oEvent.getSource();
-      var aParams = oSource && oSource.getSelectedKey() && oSource.getSelectedKey().split("/");
-      var oDialog = oSource && oSource.getParent().getParent().getParent().getParent();
-      var oFieldsInfoData = oDialog && oDialog.getModel("fieldsInfo").getData();
-      var oDataObject; //TODO - Value Help Handling Load Value Help when respective value is selected in combo Box in dialog
+    /**
+     * Called for property change in the transient context.
+     *
+     * @function
+     * @param {any} newValue New value of the property.
+     * @param {string} dataProperty Final context returned after the paginator action
+     * @param {string} mdcFieldId Final context returned after the paginator action
+     */
+    contextPropertyChange: function (newValue, dataProperty, mdcFieldId) {
+      // Called for
+      // 1. Out Parameters.
+      // 2. Transient context property change.
+      var source = Core.byId(mdcFieldId);
+      var transCtx = source && source.getBindingContext();
+      var fieldInfoModel = source && source.getModel("fieldsInfo");
+      var values = fieldInfoModel.getProperty("/values/" + dataProperty) || fieldInfoModel.getProperty("/unitData/" + dataProperty) || [];
 
-      /*
-      		if (aParams[0] === "ValueHelp") {
-      		} */
+      if (transCtx && (values.inputType === "InputWithValueHelp" || values.inputType === "InputWithUnit") && !values.valueListInfo) {
+        MassEditHandlers._setValueListInfo(transCtx, source, fieldInfoModel, dataProperty);
+      }
+
+      var isDialogOpen = fieldInfoModel && fieldInfoModel.getProperty("/isOpen");
+
+      if (!isDialogOpen || !source.getVisible()) {
+        return;
+      }
+
+      MassEditHandlers._updateSelectKey(source, dataProperty, newValue);
+    },
+
+    /**
+     * Called for change in the MDC field.
+     * This is called on selection done through VHD.
+     * This is not called on change of the dropdown as we are using a custom MassEditSelect control and not general Select.
+     *
+     * @function
+     * @param {object} event Event object for change.
+     * @param {string} propertyName Property path.
+     */
+    handleMDCFieldChange: function (event, propertyName) {
+      // Called for
+      // 1. VHD property change.
+      var source = event && event.getSource();
+      var changePromise = event && event.getParameter("promise");
+      var comboBox = source.getContent();
+
+      if (!comboBox || !propertyName) {
+        return;
+      }
+
+      changePromise.then(MassEditHandlers._updateSelectKeyForMDCFieldChange.bind(MassEditHandlers, source, propertyName)).catch(function (err) {
+        Log.warning("VHD selection couldn't be populated in the mass edit field." + err);
+      });
+    },
+
+    /**
+     * Called for selection change through the drop down.
+     *
+     * @function
+     * @param {object} event Event object for change.
+     */
+    handleSelectionChange: function (event) {
+      // Called for Manual selection from dropdown(comboBox or select)
+      // 1. VHD select.
+      // 2. Any value change in the control.
+      var source = event && event.getSource();
+      var key = source.getSelectedKey();
+      var params = source && key && key.split("/");
+      var propertyName;
+
+      if (params[0] === "UseValueHelpValue") {
+        var prevItem = event.getParameter("previousSelectedItem");
+        var selectKey = prevItem.getKey();
+        propertyName = params.slice(1).join("/");
+
+        MassEditHandlers._onVHSelect(source, propertyName, selectKey);
+
+        return;
+      }
+
+      var fieldInfoModel = source && source.getModel("fieldsInfo");
+      propertyName = MassEditHandlers._getPropertyNameFromKey(key);
+
+      MassEditHandlers._updateSuggestionForFieldsWithInParameters(fieldInfoModel, propertyName, key.startsWith("Default/") || key.startsWith("ClearFieldValue/"), true);
+
+      MassEditHandlers._updateSuggestionForFieldsWithOutParameters(fieldInfoModel, propertyName, key.startsWith("Default/") || key.startsWith("ClearFieldValue/"), false);
+
+      MassEditHandlers._updateResults(source, params, true);
+    },
+
+    /**
+     * Update selections to results and the suggests in drop downs.
+     *
+     * @function
+     * @param {MDCField} source MDC field that was changed.
+     * @param {string} propertyName Property path.
+     * @param {any} value New value.
+     */
+    _updateSelectKeyForMDCFieldChange: function (source, propertyName, value) {
+      var transCtx = source && source.getBindingContext();
+      var fieldInfoModel = source && source.getModel("fieldsInfo");
+      var values = fieldInfoModel.getProperty("/values/" + propertyName) || fieldInfoModel.getProperty("/unitData/" + propertyName) || [];
+
+      if (transCtx && (values.inputType === "InputWithValueHelp" || values.inputType === "InputWithUnit") && !values.valueListInfo) {
+        MassEditHandlers._setValueListInfo(transCtx, source, fieldInfoModel, propertyName);
+      }
+
+      MassEditHandlers._updateSuggestionForFieldsWithOutParameters(fieldInfoModel, propertyName, false, true);
+
+      MassEditHandlers._updateSuggestionForFieldsWithInParameters(fieldInfoModel, propertyName, false, true);
+
+      var formattedValue = source.getFormFormattedValue();
+
+      MassEditHandlers._updateSelectKey(source, propertyName, value, formattedValue);
+    },
+
+    /**
+     * Update suggests for all drop downs with InParameter as the propertyName.
+     *
+     * @function
+     * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.
+     * @param {string} propertyName Property path.
+     * @param {boolean} resetValues Should the values be reset to original state.
+     * @param {boolean} keepExistingSelection Should the existing selection before update remain.
+     */
+    _updateSuggestionForFieldsWithInParameters: function (fieldInfoModel, propertyName, resetValues, keepExistingSelection) {
+      var values = fieldInfoModel.getProperty("/values");
+      var unitData = fieldInfoModel.getProperty("/unitData");
+      var fieldPaths = Object.keys(values);
+      var unitFieldPaths = Object.keys(unitData);
+      fieldPaths.forEach(MassEditHandlers._updateInParameterSuggetions.bind(MassEditHandlers, fieldInfoModel, "/values/", propertyName, resetValues, keepExistingSelection));
+      unitFieldPaths.forEach(MassEditHandlers._updateInParameterSuggetions.bind(MassEditHandlers, fieldInfoModel, "/unitData/", propertyName, resetValues, keepExistingSelection));
+    },
+
+    /**
+     * Update suggests for a drop down with InParameter as the srcPropertyName.
+     *
+     * @function
+     * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.
+     * @param {string} pathPrefix Path in the runtime model.
+     * @param {string} srcPropertyName The InParameter Property path.
+     * @param {boolean} resetValues Should the values be reset to original state.
+     * @param {boolean} keepExistingSelection Should the existing selection before update remain.
+     * @param {string} propertyName Property path that needs update of suggestions.
+     */
+    _updateInParameterSuggetions: function (fieldInfoModel, pathPrefix, srcPropertyName, resetValues, keepExistingSelection, propertyName) {
+      var valueListInfo = fieldInfoModel.getProperty(pathPrefix + propertyName + "/valueListInfo");
+
+      if (valueListInfo && srcPropertyName != propertyName) {
+        var inParameters = valueListInfo.inParameters;
+
+        if (inParameters && inParameters.length > 0 && inParameters.includes(srcPropertyName)) {
+          MassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, pathPrefix + propertyName, resetValues, keepExistingSelection);
+        }
+      }
+    },
+
+    /**
+     * Update suggests for all OutParameter's drop downs of the propertyName.
+     *
+     * @function
+     * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.
+     * @param {string} propertyName Property path.
+     * @param {boolean} resetValues Should the values be reset to original state.
+     * @param {boolean} keepExistingSelection Should the existing selection before update remain.
+     */
+    _updateSuggestionForFieldsWithOutParameters: function (fieldInfoModel, propertyName, resetValues, keepExistingSelection) {
+      var valueListInfo = fieldInfoModel.getProperty("/values/" + propertyName + "/valueListInfo") || fieldInfoModel.getProperty("/unitData/" + propertyName + "/valueListInfo");
+
+      if (valueListInfo && valueListInfo.outParameters) {
+        var outParameters = valueListInfo.outParameters;
+
+        MassEditHandlers._updateOutParameterSuggetions(outParameters, fieldInfoModel, resetValues, keepExistingSelection);
+
+        var pathPrefix = fieldInfoModel.getProperty("/values/".concat(propertyName)) && "/values/".concat(propertyName) || fieldInfoModel.getProperty("/unitData/".concat(propertyName)) && "/unitData/".concat(propertyName);
+
+        if (pathPrefix) {
+          MassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, pathPrefix, false, true);
+        }
+      }
+    },
+
+    /**
+     * Update suggests for a drop down with InParameter as the srcPropertyName.
+     *
+     * @function
+     * @param {string} outParameters String arrary of OutParameter property paths.
+     * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.
+     * @param {boolean} resetValues Should the values be reset to original state.
+     * @param {boolean} keepExistingSelection Should the existing selection before update remain.
+     */
+    _updateOutParameterSuggetions: function (outParameters, fieldInfoModel, resetValues, keepExistingSelection) {
+      var values = fieldInfoModel.getProperty("/values");
+      var unitData = fieldInfoModel.getProperty("/unitData");
+      var fieldPaths = Object.keys(values);
+      var unitFieldPaths = Object.keys(unitData);
+      outParameters.forEach(function (outParameter) {
+        if (fieldPaths.includes(outParameter)) {
+          MassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, "/values/" + outParameter, resetValues, keepExistingSelection);
+        } else if (unitFieldPaths.includes(outParameter)) {
+          MassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, "/unitData/" + outParameter, resetValues, keepExistingSelection);
+        }
+      });
+    },
+
+    /**
+     * Update suggests for a drop down of a field.
+     *
+     * @function
+     * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.
+     * @param {string} fieldPathAbsolute Complete runtime property path.
+     * @param {boolean} resetValues Should the values be reset to original state.
+     * @param {boolean} keepExistingSelection Should the existing selection before update remain.
+     */
+    _updateFieldPathSuggestions: function (fieldInfoModel, fieldPathAbsolute, resetValues, keepExistingSelection) {
+      var options = fieldInfoModel.getProperty(fieldPathAbsolute);
+      var defaultOptions = options.defaultOptions;
+      var selectedKey = fieldInfoModel.getProperty(fieldPathAbsolute + "/selectedKey");
+      var existingSelection = keepExistingSelection && options.find(function (option) {
+        return option.key === selectedKey;
+      });
+
+      if (resetValues) {
+        var selectOptions = options.selectOptions;
+        options.length = 0;
+        defaultOptions.forEach(function (defaultOption) {
+          return options.push(defaultOption);
+        });
+        selectOptions.forEach(function (selectOption) {
+          return options.push(selectOption);
+        });
+      } else {
+        options.length = 0;
+        defaultOptions.forEach(function (defaultOption) {
+          return options.push(defaultOption);
+        });
+      }
+
+      fieldInfoModel.setProperty(fieldPathAbsolute, options);
+
+      if (existingSelection && !options.includes(existingSelection)) {
+        options.push(existingSelection);
+        fieldInfoModel.setProperty(fieldPathAbsolute + "/selectedKey", selectedKey);
+      }
+    },
+
+    /**
+     * Update In and Out Parameters in the MED.
+     *
+     * @function
+     * @param {Context} transCtx The transient context of the MED.
+     * @param {MDCField} source MDC field.
+     * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.
+     * @param {string} propertyName Property path.
+     */
+    _setValueListInfo: function (transCtx, source, fieldInfoModel, propertyName) {
+      var propPath = fieldInfoModel.getProperty("/values/" + propertyName) && "/values/" || fieldInfoModel.getProperty("/unitData/" + propertyName) && "/unitData/";
+
+      if (fieldInfoModel.getProperty("".concat(propPath).concat(propertyName, "/valueListInfo"))) {
+        return;
+      }
+
+      var fieldValueHelp = MassEditHandlers._getValueHelp(transCtx, source);
+
+      if (fieldValueHelp && fieldValueHelp.getDialogContent().getTable()) {
+        var inParameters = (fieldValueHelp.getInParameters() || []).map(function (inParam) {
+          return inParam.getFieldPath();
+        });
+        var outParameters = (fieldValueHelp.getInParameters() || []).map(function (outParam) {
+          return outParam.getFieldPath();
+        });
+        var info = {
+          inParameters: inParameters.map(function (inParam) {
+            return inParam.getFieldPath();
+          }),
+          outParameters: outParameters.map(function (outParam) {
+            return outParam.getFieldPath();
+          })
+        };
+        fieldInfoModel.setProperty("".concat(propPath).concat(propertyName, "/valueListInfo"), info);
+
+        if (info.outParameters.length > 0) {
+          MassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, "/values/".concat(propertyName), false, true);
+        }
+      } else {
+        MassEditHandlers._requestValueList(transCtx, source, fieldInfoModel, propertyName);
+      }
+    },
+
+    /**
+     * Request and update In and Out Parameters in the MED.
+     *
+     * @function
+     * @param {Context} transCtx The transient context of the MED.
+     * @param {MDCField} source MDC field.
+     * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.
+     * @param {string} propertyName Property path.
+     */
+    _requestValueList: function (transCtx, source, fieldInfoModel, propertyName) {
+      var metaPath = ModelHelper.getMetaPathForContext(transCtx);
+      var propertyPath = metaPath && metaPath + "/" + propertyName;
+      var dependents = source === null || source === void 0 ? void 0 : source.getDependents();
+      var fieldHelp = source === null || source === void 0 ? void 0 : source.getFieldHelp();
+      var fieldValueHelp = dependents === null || dependents === void 0 ? void 0 : dependents.find(function (dependent) {
+        return dependent.getId() === fieldHelp;
+      });
+
+      if (!(fieldValueHelp !== null && fieldValueHelp !== void 0 && fieldValueHelp.getBindingContext())) {
+        fieldValueHelp === null || fieldValueHelp === void 0 ? void 0 : fieldValueHelp.setBindingContext(transCtx);
+      }
+
+      var metaModel = transCtx.getModel().getMetaModel();
+      ValueListHelper.createVHUIModel(propertyPath, fieldValueHelp);
+      var valueListInfo = ValueListHelper.getValueListInfo(fieldValueHelp, metaModel, propertyPath);
+      valueListInfo.then(function (vLinfo) {
+        var propPath = fieldInfoModel.getProperty("/values/" + propertyName) && "/values/" || fieldInfoModel.getProperty("/unitData/" + propertyName) && "/unitData/";
+        var info = {
+          inParameters: vLinfo.inParameters.map(function (inParam) {
+            return inParam.getFieldPath();
+          }),
+          outParameters: vLinfo.outParameters.map(function (outParam) {
+            return outParam.getFieldPath();
+          })
+        };
+        fieldInfoModel.setProperty("".concat(propPath).concat(propertyName, "/valueListInfo"), info);
+
+        if (info.outParameters.length > 0) {
+          MassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, "/values/".concat(propertyName), false, true);
+        }
+      }).catch(function () {
+        Log.warning("Mass Edit: Couldn't load valueList info for ".concat(propertyPath));
+      });
+    },
+
+    /**
+     * Get field help control from MDC field.
+     *
+     * @function
+     * @param {Context} transCtx The transient context of the MED.
+     * @param {MDCField} source MDC field.
+     * @returns Field Help control.
+     */
+    _getValueHelp: function (transCtx, source) {
+      var dependents = source === null || source === void 0 ? void 0 : source.getDependents();
+      var fieldHelp = source === null || source === void 0 ? void 0 : source.getFieldHelp();
+      var fieldValueHelp = dependents === null || dependents === void 0 ? void 0 : dependents.find(function (dependent) {
+        return dependent.getId() === fieldHelp;
+      });
+      return fieldValueHelp;
+    },
+
+    /**
+     * Colled on drop down selection of VHD option.
+     *
+     * @function
+     * @param {MassEditSelect} source Custom Mass Edit Select control.
+     * @param {string} propertyName Property path.
+     * @param {string} selectKey Previous key before the VHD was selected.
+     */
+    _onVHSelect: function (source, propertyName, selectKey) {
+      // Called for
+      // 1. VHD selected.
+      var fieldInfoModel = source && source.getModel("fieldsInfo");
+      var propPath = fieldInfoModel.getProperty("/values/" + propertyName) && "/values/" || fieldInfoModel.getProperty("/unitData/" + propertyName) && "/unitData/";
+      var transCtx = source.getBindingContext();
+
+      var fieldValueHelp = MassEditHandlers._getValueHelp(transCtx, source.getParent());
+
+      if (!(fieldValueHelp !== null && fieldValueHelp !== void 0 && fieldValueHelp.getBindingContext())) {
+        fieldValueHelp === null || fieldValueHelp === void 0 ? void 0 : fieldValueHelp.setBindingContext(transCtx);
+      }
+
+      source.fireValueHelpRequest();
+      fieldInfoModel.setProperty(propPath + propertyName + "/selectedKey", selectKey);
+    },
+
+    /**
+     * Gets Property name from selection key.
+     *
+     * @function
+     * @param {string} key Selection key.
+     * @returns Property name.
+     */
+    _getPropertyNameFromKey: function (key) {
+      var propertyName = "";
+
+      if (key.startsWith("Default/") || key.startsWith("ClearFieldValue/") || key.startsWith("UseValueHelpValue/")) {
+        propertyName = key.substring(key.indexOf("/") + 1);
+      } else {
+        propertyName = key.substring(0, key.lastIndexOf("/"));
+      }
+
+      return propertyName;
+    },
+
+    /**
+     * Update selection to Custom Mass Edit Select from MDC field.
+     *
+     * @function
+     * @param {MDCField} source MDC field.
+     * @param {string} propertyName Property path.
+     * @param {string} value Value to update.
+     * @param {string} fullText Full text to use.
+     */
+    _updateSelectKey: function (source, propertyName, value, fullText) {
+      // Called for
+      // 1. VHD property change
+      // 2. Out Parameters.
+      // 3. Transient context property change.
+      var massEditSelect = source.getContent();
+
+      if (!massEditSelect || !propertyName) {
+        return;
+      }
+
+      var key = massEditSelect.getSelectedKey();
+
+      if ((key.startsWith("Default/") || key.startsWith("ClearFieldValue/")) && !value) {
+        return;
+      }
+
+      var formattedText = MassEditHandlers._valueExists(fullText) ? fullText : value;
+      var fieldInfoModel = source && source.getModel("fieldsInfo");
+      var values = fieldInfoModel.getProperty("/values/" + propertyName) || fieldInfoModel.getProperty("/unitData/" + propertyName) || [];
+      var propPath = fieldInfoModel.getProperty("/values/" + propertyName) && "/values/" || fieldInfoModel.getProperty("/unitData/" + propertyName) && "/unitData/";
+      var relatedField = values.find(function (fieldData) {
+        var _fieldData$textInfo;
+
+        return (fieldData === null || fieldData === void 0 ? void 0 : (_fieldData$textInfo = fieldData.textInfo) === null || _fieldData$textInfo === void 0 ? void 0 : _fieldData$textInfo.value) === value || fieldData.text === value;
+      });
+
+      if (relatedField) {
+        if (fullText && relatedField.textInfo && relatedField.textInfo.descriptionPath && (relatedField.text != formattedText || relatedField.textInfo.fullText != formattedText)) {
+          // Update the full text only when provided.
+          relatedField.text = formattedText;
+          relatedField.textInfo.fullText = formattedText;
+          relatedField.textInfo.description = source.getAdditionalValue();
+        }
+
+        if (relatedField.key === key) {
+          fieldInfoModel.setProperty(propPath + propertyName + "/selectedKey", key);
+          return;
+        }
+
+        key = relatedField.key;
+      } else if ([undefined, null, ""].indexOf(value) === -1) {
+        key = propertyName + "/" + value;
+        var selectionInfo = {
+          text: formattedText,
+          key: key,
+          textInfo: {
+            description: source.getAdditionalValue(),
+            descriptionPath: values && values.textInfo && values.textInfo.descriptionPath,
+            fullText: formattedText,
+            textArrangement: source.getDisplay(),
+            value: source.getValue(),
+            valuePath: propertyName
+          }
+        };
+        values.push(selectionInfo);
+        values.selectOptions = values.selectOptions || [];
+        values.selectOptions.push(selectionInfo);
+        fieldInfoModel.setProperty(propPath + propertyName, values);
+      } else {
+        key = "Default/" + propertyName;
+      }
+
+      fieldInfoModel.setProperty(propPath + propertyName + "/selectedKey", key);
+
+      MassEditHandlers._updateResults(massEditSelect);
+    },
+
+    /**
+     * Get Value from Drop down.
+     *
+     * @function
+     * @param {Control} source Drop down control.
+     * @returns {string} Value of selection.
+     */
+    _getValue: function (source) {
+      var _getSelectedItem;
+
+      return source.getMetadata().getName() === "sap.fe.core.controls.MassEditSelect" ? (_getSelectedItem = source.getSelectedItem()) === null || _getSelectedItem === void 0 ? void 0 : _getSelectedItem.getText() : source.getValue();
+    },
+    _getValueOnEmpty: function (oSource, fieldsInfoModel, value, sPropertyName) {
+      if (!value) {
+        var values = fieldsInfoModel.getProperty("/values/".concat(sPropertyName)) || fieldsInfoModel.getProperty("/unitData/".concat(sPropertyName)) || [];
+
+        if (values.unitProperty) {
+          value = 0;
+          oSource.setValue(value);
+        } else if (values.inputType === "CheckBox") {
+          value = null;
+        }
+      }
+
+      return value;
+    },
+    _valueExists: function (value) {
+      return value != undefined && value != null;
+    },
+
+    /**
+     * Updates selections to runtime model.
+     *
+     * @function
+     * @param {Control} oSource Drop down control.
+     * @param {Array} aParams Parts of key in runtime model.
+     * @param {boolean} updateTransCtx Should transient context be updated with the value.
+     */
+    _updateResults: function (oSource) {
+      var aParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var updateTransCtx = arguments.length > 2 ? arguments[2] : undefined;
+      // Called for
+      // 1. VHD property change.
+      // 2. Out parameter.
+      // 3. transient context property change.
+      var fieldsInfoModel = oSource && oSource.getModel("fieldsInfo");
+      var oFieldsInfoData = fieldsInfoModel && fieldsInfoModel.getData();
+
+      var value = MassEditHandlers._getValue(oSource);
+
+      aParams = aParams.length > 0 ? aParams : oSource && oSource.getSelectedKey() && oSource.getSelectedKey().split("/");
+      var oDataObject;
+      var sPropertyName = oSource.getId().substring(oSource.getId().lastIndexOf(":") + 1);
 
       if (aParams[0] === "Default") {
         oDataObject = {
@@ -33,29 +538,29 @@ sap.ui.define([], function () {
           value: aParams[0]
         };
       } else if (aParams[0] === "ClearFieldValue") {
+        value = "";
+        value = MassEditHandlers._getValueOnEmpty(oSource, fieldsInfoModel, value, sPropertyName);
         oDataObject = {
           keyValue: aParams[1],
-          value: ""
+          value: value
         };
       } else if (!aParams) {
-        var sPropertyName = oSource.getId().substring(oSource.getId().lastIndexOf(":") + 1);
+        value = MassEditHandlers._getValueOnEmpty(oSource, fieldsInfoModel, value, sPropertyName);
         oDataObject = {
           keyValue: sPropertyName,
-          value: oSource.getValue()
+          value: value
         };
       } else {
-        var aRelatedField = aParams[0] && oFieldsInfoData.values && oFieldsInfoData.values[aParams[0]].filter(function (oFieldData) {
-          return oFieldData.text === oSource.getValue();
-        });
-        var iValueIndex = oFieldsInfoData.values[aParams[0]].findIndex(function (data) {
-          return typeof data.text === "boolean" && data.text === Boolean(oSource.getValue());
+        var propertyName = aParams.slice(0, -1).join("/");
+        var propertyValues = fieldsInfoModel.getProperty("/values/" + propertyName) || fieldsInfoModel.getProperty("/unitData/" + propertyName) || [];
+        var relatedField = (propertyValues || []).find(function (oFieldData) {
+          var _oFieldData$textInfo;
+
+          return (oFieldData === null || oFieldData === void 0 ? void 0 : (_oFieldData$textInfo = oFieldData.textInfo) === null || _oFieldData$textInfo === void 0 ? void 0 : _oFieldData$textInfo.value) === value || oFieldData.text === value;
         });
-        oDataObject = aRelatedField && aRelatedField[0] && aRelatedField[0].textInfo ? {
-          keyValue: aParams[0],
-          value: aRelatedField[0].textInfo.value
-        } : {
-          keyValue: aParams[0],
-          value: iValueIndex !== -1 ? oFieldsInfoData.values[aParams[0]][iValueIndex].text : oSource.getValue()
+        oDataObject = {
+          keyValue: propertyName,
+          value: relatedField.textInfo && MassEditHandlers._valueExists(relatedField.textInfo.value) ? relatedField.textInfo.value : relatedField.text
         };
       }
 
@@ -72,8 +577,18 @@ sap.ui.define([], function () {
       } else {
         oFieldsInfoData.results.push(oDataObject);
       }
+
+      if (updateTransCtx) {
+        var transCtx = oSource.getBindingContext();
+
+        if (aParams[0] === "Default" || aParams[0] === "ClearFieldValue") {
+          transCtx.setProperty(oDataObject.keyValue, null);
+        } else if (oDataObject) {
+          transCtx.setProperty(oDataObject.keyValue, oDataObject.value);
+        }
+      }
     }
   };
   return MassEditHandlers;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["MassEditHandlers.ts"],"names":["MassEditHandlers","contextPropertyChange","newValue","dataProperty","mdcFieldId","source","Core","byId","transCtx","getBindingContext","fieldInfoModel","getModel","values","getProperty","inputType","valueListInfo","_setValueListInfo","isDialogOpen","getVisible","_updateSelectKey","handleMDCFieldChange","event","propertyName","getSource","changePromise","getParameter","comboBox","getContent","then","_updateSelectKeyForMDCFieldChange","bind","catch","err","Log","warning","handleSelectionChange","key","getSelectedKey","params","split","prevItem","selectKey","getKey","slice","join","_onVHSelect","_getPropertyNameFromKey","_updateSuggestionForFieldsWithInParameters","startsWith","_updateSuggestionForFieldsWithOutParameters","_updateResults","value","formattedValue","getFormFormattedValue","resetValues","keepExistingSelection","unitData","fieldPaths","Object","keys","unitFieldPaths","forEach","_updateInParameterSuggetions","pathPrefix","srcPropertyName","inParameters","length","includes","_updateFieldPathSuggestions","outParameters","_updateOutParameterSuggetions","outParameter","fieldPathAbsolute","options","defaultOptions","selectedKey","existingSelection","find","option","selectOptions","defaultOption","push","selectOption","setProperty","propPath","fieldValueHelp","_getValueHelp","getDialogContent","getTable","getInParameters","map","inParam","getFieldPath","outParam","info","_requestValueList","metaPath","ModelHelper","getMetaPathForContext","propertyPath","dependents","getDependents","fieldHelp","getFieldHelp","dependent","getId","setBindingContext","metaModel","getMetaModel","ValueListHelper","createVHUIModel","getValueListInfo","vLinfo","getParent","fireValueHelpRequest","substring","indexOf","lastIndexOf","fullText","massEditSelect","formattedText","_valueExists","relatedField","fieldData","textInfo","text","descriptionPath","description","getAdditionalValue","undefined","selectionInfo","textArrangement","getDisplay","getValue","valuePath","_getValue","getMetadata","getName","getSelectedItem","getText","_getValueOnEmpty","oSource","fieldsInfoModel","sPropertyName","unitProperty","setValue","aParams","updateTransCtx","oFieldsInfoData","getData","oDataObject","keyValue","propertyValues","oFieldData","bExistingElementindex","i","results"],"mappings":"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","sourceRoot":".","sourcesContent":["/**\n * Constructor for a new Visual Filter Container.\n * Used for visual filters\n *\n * @param {string} [sId] ID for the new control, generated automatically if no ID is given\n * @extends sap.ui.mdc.filterbar.IFilterContainer\n * @class\n * @private\n * @alias sap.fe.core.controls.filterbar.VisualFilterContainer\n */\nimport Log from \"sap/base/Log\";\nimport ModelHelper from \"sap/fe/core/helpers/ModelHelper\";\nimport ValueListHelper from \"sap/fe/macros/internal/valuehelp/ValueListHelper\";\nimport ComboBox from \"sap/m/ComboBox\";\nimport Select from \"sap/m/Select\";\nimport Control from \"sap/ui/core/Control\";\nimport Core from \"sap/ui/core/Core\";\nimport Field from \"sap/ui/mdc/Field\";\nimport InParameter from \"sap/ui/mdc/field/InParameter\";\nimport OutParameter from \"sap/ui/mdc/field/OutParameter\";\nimport JSONModel from \"sap/ui/model/json/JSONModel\";\nimport Context from \"sap/ui/model/odata/v4/Context\";\n\nconst MassEditHandlers: any = {\n\t/**\n\t * Called for property change in the transient context.\n\t *\n\t * @function\n\t * @param {any} newValue New value of the property.\n\t * @param {string} dataProperty Final context returned after the paginator action\n\t * @param {string} mdcFieldId Final context returned after the paginator action\n\t */\n\tcontextPropertyChange: function (newValue: any, dataProperty: string, mdcFieldId: string) {\n\t\t// Called for\n\t\t// 1. Out Parameters.\n\t\t// 2. Transient context property change.\n\n\t\tconst source = Core.byId(mdcFieldId) as Field;\n\t\tconst transCtx = source && (source.getBindingContext() as Context);\n\t\tconst fieldInfoModel = source && (source.getModel(\"fieldsInfo\") as JSONModel);\n\t\tconst values =\n\t\t\tfieldInfoModel.getProperty(\"/values/\" + dataProperty) || fieldInfoModel.getProperty(\"/unitData/\" + dataProperty) || [];\n\n\t\tif (transCtx && (values.inputType === \"InputWithValueHelp\" || values.inputType === \"InputWithUnit\") && !values.valueListInfo) {\n\t\t\tMassEditHandlers._setValueListInfo(transCtx, source, fieldInfoModel, dataProperty);\n\t\t}\n\n\t\tconst isDialogOpen = fieldInfoModel && fieldInfoModel.getProperty(\"/isOpen\");\n\t\tif (!isDialogOpen || !source.getVisible()) {\n\t\t\treturn;\n\t\t}\n\n\t\tMassEditHandlers._updateSelectKey(source, dataProperty, newValue);\n\t},\n\n\t/**\n\t * Called for change in the MDC field.\n\t * This is called on selection done through VHD.\n\t * This is not called on change of the dropdown as we are using a custom MassEditSelect control and not general Select.\n\t *\n\t * @function\n\t * @param {object} event Event object for change.\n\t * @param {string} propertyName Property path.\n\t */\n\thandleMDCFieldChange: function (event: any, propertyName: string) {\n\t\t// Called for\n\t\t// 1. VHD property change.\n\n\t\tconst source = event && event.getSource();\n\t\tconst changePromise = event && event.getParameter(\"promise\");\n\t\tconst comboBox = source.getContent();\n\t\tif (!comboBox || !propertyName) {\n\t\t\treturn;\n\t\t}\n\n\t\tchangePromise\n\t\t\t.then(MassEditHandlers._updateSelectKeyForMDCFieldChange.bind(MassEditHandlers, source, propertyName))\n\t\t\t.catch((err: any) => {\n\t\t\t\tLog.warning(\"VHD selection couldn't be populated in the mass edit field.\" + err);\n\t\t\t});\n\t},\n\n\t/**\n\t * Called for selection change through the drop down.\n\t *\n\t * @function\n\t * @param {object} event Event object for change.\n\t */\n\thandleSelectionChange: function (event: any) {\n\t\t// Called for Manual selection from dropdown(comboBox or select)\n\t\t// 1. VHD select.\n\t\t// 2. Any value change in the control.\n\n\t\tconst source = (event && event.getSource()) as any;\n\t\tconst key = source.getSelectedKey() as string;\n\t\tconst params = source && key && key.split(\"/\");\n\t\tlet propertyName;\n\n\t\tif (params[0] === \"UseValueHelpValue\") {\n\t\t\tconst prevItem = event.getParameter(\"previousSelectedItem\");\n\t\t\tconst selectKey = prevItem.getKey();\n\t\t\tpropertyName = params.slice(1).join(\"/\");\n\t\t\tMassEditHandlers._onVHSelect(source, propertyName, selectKey);\n\t\t\treturn;\n\t\t}\n\n\t\tconst fieldInfoModel = source && (source.getModel(\"fieldsInfo\") as JSONModel);\n\t\tpropertyName = MassEditHandlers._getPropertyNameFromKey(key);\n\t\tMassEditHandlers._updateSuggestionForFieldsWithInParameters(\n\t\t\tfieldInfoModel,\n\t\t\tpropertyName,\n\t\t\tkey.startsWith(\"Default/\") || key.startsWith(\"ClearFieldValue/\"),\n\t\t\ttrue\n\t\t);\n\t\tMassEditHandlers._updateSuggestionForFieldsWithOutParameters(\n\t\t\tfieldInfoModel,\n\t\t\tpropertyName,\n\t\t\tkey.startsWith(\"Default/\") || key.startsWith(\"ClearFieldValue/\"),\n\t\t\tfalse\n\t\t);\n\t\tMassEditHandlers._updateResults(source, params, true);\n\t},\n\n\t/**\n\t * Update selections to results and the suggests in drop downs.\n\t *\n\t * @function\n\t * @param {MDCField} source MDC field that was changed.\n\t * @param {string} propertyName Property path.\n\t * @param {any} value New value.\n\t */\n\t_updateSelectKeyForMDCFieldChange: function (source: any, propertyName: string, value: any): void {\n\t\tconst transCtx = source && source.getBindingContext();\n\t\tconst fieldInfoModel = source && (source.getModel(\"fieldsInfo\") as JSONModel);\n\t\tconst values =\n\t\t\tfieldInfoModel.getProperty(\"/values/\" + propertyName) || fieldInfoModel.getProperty(\"/unitData/\" + propertyName) || [];\n\n\t\tif (transCtx && (values.inputType === \"InputWithValueHelp\" || values.inputType === \"InputWithUnit\") && !values.valueListInfo) {\n\t\t\tMassEditHandlers._setValueListInfo(transCtx, source, fieldInfoModel, propertyName);\n\t\t}\n\n\t\tMassEditHandlers._updateSuggestionForFieldsWithOutParameters(fieldInfoModel, propertyName, false, true);\n\t\tMassEditHandlers._updateSuggestionForFieldsWithInParameters(fieldInfoModel, propertyName, false, true);\n\n\t\tconst formattedValue = source.getFormFormattedValue();\n\t\tMassEditHandlers._updateSelectKey(source, propertyName, value, formattedValue);\n\t},\n\n\t/**\n\t * Update suggests for all drop downs with InParameter as the propertyName.\n\t *\n\t * @function\n\t * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.\n\t * @param {string} propertyName Property path.\n\t * @param {boolean} resetValues Should the values be reset to original state.\n\t * @param {boolean} keepExistingSelection Should the existing selection before update remain.\n\t */\n\t_updateSuggestionForFieldsWithInParameters: function (\n\t\tfieldInfoModel: JSONModel,\n\t\tpropertyName: string,\n\t\tresetValues: boolean,\n\t\tkeepExistingSelection: boolean\n\t): void {\n\t\tconst values = fieldInfoModel.getProperty(\"/values\");\n\t\tconst unitData = fieldInfoModel.getProperty(\"/unitData\");\n\t\tconst fieldPaths = Object.keys(values);\n\t\tconst unitFieldPaths = Object.keys(unitData);\n\n\t\tfieldPaths.forEach(\n\t\t\tMassEditHandlers._updateInParameterSuggetions.bind(\n\t\t\t\tMassEditHandlers,\n\t\t\t\tfieldInfoModel,\n\t\t\t\t\"/values/\",\n\t\t\t\tpropertyName,\n\t\t\t\tresetValues,\n\t\t\t\tkeepExistingSelection\n\t\t\t)\n\t\t);\n\t\tunitFieldPaths.forEach(\n\t\t\tMassEditHandlers._updateInParameterSuggetions.bind(\n\t\t\t\tMassEditHandlers,\n\t\t\t\tfieldInfoModel,\n\t\t\t\t\"/unitData/\",\n\t\t\t\tpropertyName,\n\t\t\t\tresetValues,\n\t\t\t\tkeepExistingSelection\n\t\t\t)\n\t\t);\n\t},\n\n\t/**\n\t * Update suggests for a drop down with InParameter as the srcPropertyName.\n\t *\n\t * @function\n\t * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.\n\t * @param {string} pathPrefix Path in the runtime model.\n\t * @param {string} srcPropertyName The InParameter Property path.\n\t * @param {boolean} resetValues Should the values be reset to original state.\n\t * @param {boolean} keepExistingSelection Should the existing selection before update remain.\n\t * @param {string} propertyName Property path that needs update of suggestions.\n\t */\n\t_updateInParameterSuggetions: function (\n\t\tfieldInfoModel: JSONModel,\n\t\tpathPrefix: string,\n\t\tsrcPropertyName: string,\n\t\tresetValues: boolean,\n\t\tkeepExistingSelection: boolean,\n\t\tpropertyName: string\n\t) {\n\t\tconst valueListInfo = fieldInfoModel.getProperty(pathPrefix + propertyName + \"/valueListInfo\");\n\t\tif (valueListInfo && srcPropertyName != propertyName) {\n\t\t\tconst inParameters = valueListInfo.inParameters;\n\t\t\tif (inParameters && inParameters.length > 0 && inParameters.includes(srcPropertyName)) {\n\t\t\t\tMassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, pathPrefix + propertyName, resetValues, keepExistingSelection);\n\t\t\t}\n\t\t}\n\t},\n\n\t/**\n\t * Update suggests for all OutParameter's drop downs of the propertyName.\n\t *\n\t * @function\n\t * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.\n\t * @param {string} propertyName Property path.\n\t * @param {boolean} resetValues Should the values be reset to original state.\n\t * @param {boolean} keepExistingSelection Should the existing selection before update remain.\n\t */\n\t_updateSuggestionForFieldsWithOutParameters: function (\n\t\tfieldInfoModel: JSONModel,\n\t\tpropertyName: string,\n\t\tresetValues: boolean,\n\t\tkeepExistingSelection: boolean\n\t): void {\n\t\tconst valueListInfo =\n\t\t\tfieldInfoModel.getProperty(\"/values/\" + propertyName + \"/valueListInfo\") ||\n\t\t\tfieldInfoModel.getProperty(\"/unitData/\" + propertyName + \"/valueListInfo\");\n\n\t\tif (valueListInfo && valueListInfo.outParameters) {\n\t\t\tconst outParameters = valueListInfo.outParameters;\n\t\t\tMassEditHandlers._updateOutParameterSuggetions(outParameters, fieldInfoModel, resetValues, keepExistingSelection);\n\t\t\tconst pathPrefix =\n\t\t\t\t(fieldInfoModel.getProperty(`/values/${propertyName}`) && `/values/${propertyName}`) ||\n\t\t\t\t(fieldInfoModel.getProperty(`/unitData/${propertyName}`) && `/unitData/${propertyName}`);\n\t\t\tif (pathPrefix) {\n\t\t\t\tMassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, pathPrefix, false, true);\n\t\t\t}\n\t\t}\n\t},\n\n\t/**\n\t * Update suggests for a drop down with InParameter as the srcPropertyName.\n\t *\n\t * @function\n\t * @param {string} outParameters String arrary of OutParameter property paths.\n\t * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.\n\t * @param {boolean} resetValues Should the values be reset to original state.\n\t * @param {boolean} keepExistingSelection Should the existing selection before update remain.\n\t */\n\t_updateOutParameterSuggetions: function (\n\t\toutParameters: string[],\n\t\tfieldInfoModel: JSONModel,\n\t\tresetValues: boolean,\n\t\tkeepExistingSelection: boolean\n\t) {\n\t\tconst values = fieldInfoModel.getProperty(\"/values\");\n\t\tconst unitData = fieldInfoModel.getProperty(\"/unitData\");\n\t\tconst fieldPaths = Object.keys(values);\n\t\tconst unitFieldPaths = Object.keys(unitData);\n\n\t\toutParameters.forEach((outParameter: string) => {\n\t\t\tif (fieldPaths.includes(outParameter)) {\n\t\t\t\tMassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, \"/values/\" + outParameter, resetValues, keepExistingSelection);\n\t\t\t} else if (unitFieldPaths.includes(outParameter)) {\n\t\t\t\tMassEditHandlers._updateFieldPathSuggestions(\n\t\t\t\t\tfieldInfoModel,\n\t\t\t\t\t\"/unitData/\" + outParameter,\n\t\t\t\t\tresetValues,\n\t\t\t\t\tkeepExistingSelection\n\t\t\t\t);\n\t\t\t}\n\t\t});\n\t},\n\n\t/**\n\t * Update suggests for a drop down of a field.\n\t *\n\t * @function\n\t * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.\n\t * @param {string} fieldPathAbsolute Complete runtime property path.\n\t * @param {boolean} resetValues Should the values be reset to original state.\n\t * @param {boolean} keepExistingSelection Should the existing selection before update remain.\n\t */\n\t_updateFieldPathSuggestions: function (\n\t\tfieldInfoModel: JSONModel,\n\t\tfieldPathAbsolute: string,\n\t\tresetValues: boolean,\n\t\tkeepExistingSelection: boolean\n\t) {\n\t\tconst options = fieldInfoModel.getProperty(fieldPathAbsolute);\n\t\tconst defaultOptions = options.defaultOptions;\n\t\tconst selectedKey = fieldInfoModel.getProperty(fieldPathAbsolute + \"/selectedKey\");\n\t\tconst existingSelection = keepExistingSelection && options.find((option: any) => option.key === selectedKey);\n\t\tif (resetValues) {\n\t\t\tconst selectOptions = options.selectOptions;\n\t\t\toptions.length = 0;\n\t\t\tdefaultOptions.forEach((defaultOption: any) => options.push(defaultOption));\n\t\t\tselectOptions.forEach((selectOption: any) => options.push(selectOption));\n\t\t} else {\n\t\t\toptions.length = 0;\n\t\t\tdefaultOptions.forEach((defaultOption: any) => options.push(defaultOption));\n\t\t}\n\n\t\tfieldInfoModel.setProperty(fieldPathAbsolute, options);\n\n\t\tif (existingSelection && !options.includes(existingSelection)) {\n\t\t\toptions.push(existingSelection);\n\t\t\tfieldInfoModel.setProperty(fieldPathAbsolute + \"/selectedKey\", selectedKey);\n\t\t}\n\t},\n\n\t/**\n\t * Update In and Out Parameters in the MED.\n\t *\n\t * @function\n\t * @param {Context} transCtx The transient context of the MED.\n\t * @param {MDCField} source MDC field.\n\t * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.\n\t * @param {string} propertyName Property path.\n\t */\n\t_setValueListInfo: function (transCtx: Context, source: Field, fieldInfoModel: JSONModel, propertyName: string): void {\n\t\tconst propPath =\n\t\t\t(fieldInfoModel.getProperty(\"/values/\" + propertyName) && \"/values/\") ||\n\t\t\t(fieldInfoModel.getProperty(\"/unitData/\" + propertyName) && \"/unitData/\");\n\n\t\tif (fieldInfoModel.getProperty(`${propPath}${propertyName}/valueListInfo`)) {\n\t\t\treturn;\n\t\t}\n\t\tconst fieldValueHelp = MassEditHandlers._getValueHelp(transCtx, source);\n\t\tif (fieldValueHelp && fieldValueHelp.getDialogContent().getTable()) {\n\t\t\tconst inParameters = (fieldValueHelp.getInParameters() || []).map((inParam: InParameter) => inParam.getFieldPath());\n\t\t\tconst outParameters = (fieldValueHelp.getInParameters() || []).map((outParam: OutParameter) => outParam.getFieldPath());\n\t\t\tconst info: any = {\n\t\t\t\tinParameters: inParameters.map((inParam: any) => inParam.getFieldPath()),\n\t\t\t\toutParameters: outParameters.map((outParam: any) => outParam.getFieldPath())\n\t\t\t};\n\t\t\tfieldInfoModel.setProperty(`${propPath}${propertyName}/valueListInfo`, info);\n\t\t\tif (info.outParameters.length > 0) {\n\t\t\t\tMassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, `/values/${propertyName}`, false, true);\n\t\t\t}\n\t\t} else {\n\t\t\tMassEditHandlers._requestValueList(transCtx, source, fieldInfoModel, propertyName);\n\t\t}\n\t},\n\n\t/**\n\t * Request and update In and Out Parameters in the MED.\n\t *\n\t * @function\n\t * @param {Context} transCtx The transient context of the MED.\n\t * @param {MDCField} source MDC field.\n\t * @param {JSONModel} fieldInfoModel Runtime model with parameters store information.\n\t * @param {string} propertyName Property path.\n\t */\n\t_requestValueList: function (transCtx: Context, source: Field, fieldInfoModel: JSONModel, propertyName: string): void {\n\t\tconst metaPath = ModelHelper.getMetaPathForContext(transCtx);\n\t\tconst propertyPath = (metaPath && metaPath + \"/\" + propertyName) as string;\n\t\tconst dependents = (source as any)?.getDependents();\n\t\tconst fieldHelp = source?.getFieldHelp();\n\t\tconst fieldValueHelp = dependents?.find((dependent: any) => dependent.getId() === fieldHelp);\n\t\tif (!fieldValueHelp?.getBindingContext()) {\n\t\t\tfieldValueHelp?.setBindingContext(transCtx);\n\t\t}\n\t\tconst metaModel = transCtx.getModel().getMetaModel();\n\t\tValueListHelper.createVHUIModel(propertyPath, fieldValueHelp);\n\t\tconst valueListInfo = ValueListHelper.getValueListInfo(fieldValueHelp, metaModel, propertyPath) as Promise<any>;\n\n\t\tvalueListInfo\n\t\t\t.then((vLinfo: any) => {\n\t\t\t\tconst propPath =\n\t\t\t\t\t(fieldInfoModel.getProperty(\"/values/\" + propertyName) && \"/values/\") ||\n\t\t\t\t\t(fieldInfoModel.getProperty(\"/unitData/\" + propertyName) && \"/unitData/\");\n\t\t\t\tconst info: any = {\n\t\t\t\t\tinParameters: vLinfo.inParameters.map((inParam: any) => inParam.getFieldPath()),\n\t\t\t\t\toutParameters: vLinfo.outParameters.map((outParam: any) => outParam.getFieldPath())\n\t\t\t\t};\n\t\t\t\tfieldInfoModel.setProperty(`${propPath}${propertyName}/valueListInfo`, info);\n\t\t\t\tif (info.outParameters.length > 0) {\n\t\t\t\t\tMassEditHandlers._updateFieldPathSuggestions(fieldInfoModel, `/values/${propertyName}`, false, true);\n\t\t\t\t}\n\t\t\t})\n\t\t\t.catch(() => {\n\t\t\t\tLog.warning(`Mass Edit: Couldn't load valueList info for ${propertyPath}`);\n\t\t\t});\n\t},\n\n\t/**\n\t * Get field help control from MDC field.\n\t *\n\t * @function\n\t * @param {Context} transCtx The transient context of the MED.\n\t * @param {MDCField} source MDC field.\n\t * @returns Field Help control.\n\t */\n\t_getValueHelp: function (transCtx: Context, source: any): any {\n\t\tconst dependents = source?.getDependents();\n\t\tconst fieldHelp = source?.getFieldHelp();\n\t\tconst fieldValueHelp = dependents?.find((dependent: any) => dependent.getId() === fieldHelp);\n\t\treturn fieldValueHelp;\n\t},\n\n\t/**\n\t * Colled on drop down selection of VHD option.\n\t *\n\t * @function\n\t * @param {MassEditSelect} source Custom Mass Edit Select control.\n\t * @param {string} propertyName Property path.\n\t * @param {string} selectKey Previous key before the VHD was selected.\n\t */\n\t_onVHSelect: function (source: any, propertyName: string, selectKey: string): void {\n\t\t// Called for\n\t\t// 1. VHD selected.\n\n\t\tconst fieldInfoModel = source && source.getModel(\"fieldsInfo\");\n\t\tconst propPath =\n\t\t\t(fieldInfoModel.getProperty(\"/values/\" + propertyName) && \"/values/\") ||\n\t\t\t(fieldInfoModel.getProperty(\"/unitData/\" + propertyName) && \"/unitData/\");\n\t\tconst transCtx = source.getBindingContext();\n\t\tconst fieldValueHelp = MassEditHandlers._getValueHelp(transCtx, source.getParent());\n\t\tif (!fieldValueHelp?.getBindingContext()) {\n\t\t\tfieldValueHelp?.setBindingContext(transCtx);\n\t\t}\n\t\tsource.fireValueHelpRequest();\n\n\t\tfieldInfoModel.setProperty(propPath + propertyName + \"/selectedKey\", selectKey);\n\t},\n\n\t/**\n\t * Gets Property name from selection key.\n\t *\n\t * @function\n\t * @param {string} key Selection key.\n\t * @returns Property name.\n\t */\n\t_getPropertyNameFromKey: function (key: string) {\n\t\tlet propertyName = \"\";\n\t\tif (key.startsWith(\"Default/\") || key.startsWith(\"ClearFieldValue/\") || key.startsWith(\"UseValueHelpValue/\")) {\n\t\t\tpropertyName = key.substring(key.indexOf(\"/\") + 1);\n\t\t} else {\n\t\t\tpropertyName = key.substring(0, key.lastIndexOf(\"/\"));\n\t\t}\n\t\treturn propertyName;\n\t},\n\n\t/**\n\t * Update selection to Custom Mass Edit Select from MDC field.\n\t *\n\t * @function\n\t * @param {MDCField} source MDC field.\n\t * @param {string} propertyName Property path.\n\t * @param {string} value Value to update.\n\t * @param {string} fullText Full text to use.\n\t */\n\t_updateSelectKey: function (source: Field, propertyName: string, value: any, fullText?: any): void {\n\t\t// Called for\n\t\t// 1. VHD property change\n\t\t// 2. Out Parameters.\n\t\t// 3. Transient context property change.\n\n\t\tconst massEditSelect = (source.getContent() as any) as Select;\n\t\tif (!massEditSelect || !propertyName) {\n\t\t\treturn;\n\t\t}\n\t\tlet key: string = massEditSelect.getSelectedKey();\n\t\tif ((key.startsWith(\"Default/\") || key.startsWith(\"ClearFieldValue/\")) && !value) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst formattedText = MassEditHandlers._valueExists(fullText) ? fullText : value;\n\t\tconst fieldInfoModel = source && ((source as any).getModel(\"fieldsInfo\") as JSONModel);\n\t\tconst values =\n\t\t\tfieldInfoModel.getProperty(\"/values/\" + propertyName) || fieldInfoModel.getProperty(\"/unitData/\" + propertyName) || [];\n\t\tconst propPath =\n\t\t\t(fieldInfoModel.getProperty(\"/values/\" + propertyName) && \"/values/\") ||\n\t\t\t(fieldInfoModel.getProperty(\"/unitData/\" + propertyName) && \"/unitData/\");\n\n\t\tconst relatedField = values.find((fieldData: any) => fieldData?.textInfo?.value === value || fieldData.text === value);\n\n\t\tif (relatedField) {\n\t\t\tif (\n\t\t\t\tfullText &&\n\t\t\t\trelatedField.textInfo &&\n\t\t\t\trelatedField.textInfo.descriptionPath &&\n\t\t\t\t(relatedField.text != formattedText || relatedField.textInfo.fullText != formattedText)\n\t\t\t) {\n\t\t\t\t// Update the full text only when provided.\n\t\t\t\trelatedField.text = formattedText;\n\t\t\t\trelatedField.textInfo.fullText = formattedText;\n\t\t\t\trelatedField.textInfo.description = source.getAdditionalValue();\n\t\t\t}\n\t\t\tif (relatedField.key === key) {\n\t\t\t\tfieldInfoModel.setProperty(propPath + propertyName + \"/selectedKey\", key);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tkey = relatedField.key;\n\t\t} else if ([undefined, null, \"\"].indexOf(value) === -1) {\n\t\t\tkey = propertyName + \"/\" + value;\n\t\t\tconst selectionInfo = {\n\t\t\t\ttext: formattedText,\n\t\t\t\tkey,\n\t\t\t\ttextInfo: {\n\t\t\t\t\tdescription: source.getAdditionalValue(),\n\t\t\t\t\tdescriptionPath: values && values.textInfo && values.textInfo.descriptionPath,\n\t\t\t\t\tfullText: formattedText,\n\t\t\t\t\ttextArrangement: source.getDisplay(),\n\t\t\t\t\tvalue: source.getValue(),\n\t\t\t\t\tvaluePath: propertyName\n\t\t\t\t}\n\t\t\t};\n\t\t\tvalues.push(selectionInfo);\n\t\t\tvalues.selectOptions = values.selectOptions || [];\n\t\t\tvalues.selectOptions.push(selectionInfo);\n\t\t\tfieldInfoModel.setProperty(propPath + propertyName, values);\n\t\t} else {\n\t\t\tkey = \"Default/\" + propertyName;\n\t\t}\n\n\t\tfieldInfoModel.setProperty(propPath + propertyName + \"/selectedKey\", key);\n\t\tMassEditHandlers._updateResults(massEditSelect);\n\t},\n\n\t/**\n\t * Get Value from Drop down.\n\t *\n\t * @function\n\t * @param {Control} source Drop down control.\n\t * @returns {string} Value of selection.\n\t */\n\t_getValue: function (source: Control) {\n\t\treturn source.getMetadata().getName() === \"sap.fe.core.controls.MassEditSelect\"\n\t\t\t? (source as Select).getSelectedItem()?.getText()\n\t\t\t: (source as ComboBox).getValue();\n\t},\n\n\t_getValueOnEmpty: function (oSource: any, fieldsInfoModel: JSONModel, value: any, sPropertyName: string) {\n\t\tif (!value) {\n\t\t\tconst values =\n\t\t\t\tfieldsInfoModel.getProperty(`/values/${sPropertyName}`) || fieldsInfoModel.getProperty(`/unitData/${sPropertyName}`) || [];\n\t\t\tif (values.unitProperty) {\n\t\t\t\tvalue = 0;\n\t\t\t\toSource.setValue(value);\n\t\t\t} else if (values.inputType === \"CheckBox\") {\n\t\t\t\tvalue = null;\n\t\t\t}\n\t\t}\n\t\treturn value;\n\t},\n\n\t_valueExists: function (value: any) {\n\t\treturn value != undefined && value != null;\n\t},\n\n\t/**\n\t * Updates selections to runtime model.\n\t *\n\t * @function\n\t * @param {Control} oSource Drop down control.\n\t * @param {Array} aParams Parts of key in runtime model.\n\t * @param {boolean} updateTransCtx Should transient context be updated with the value.\n\t */\n\t_updateResults: function (oSource: any, aParams: Array<string> = [], updateTransCtx: boolean) {\n\t\t// Called for\n\t\t// 1. VHD property change.\n\t\t// 2. Out parameter.\n\t\t// 3. transient context property change.\n\t\tconst fieldsInfoModel = oSource && oSource.getModel(\"fieldsInfo\");\n\t\tconst oFieldsInfoData = fieldsInfoModel && fieldsInfoModel.getData();\n\t\tlet value = MassEditHandlers._getValue(oSource as Control);\n\t\taParams = aParams.length > 0 ? aParams : oSource && oSource.getSelectedKey() && oSource.getSelectedKey().split(\"/\");\n\n\t\tlet oDataObject;\n\t\tconst sPropertyName = oSource.getId().substring(oSource.getId().lastIndexOf(\":\") + 1);\n\n\t\tif (aParams[0] === \"Default\") {\n\t\t\toDataObject = {\n\t\t\t\tkeyValue: aParams[1],\n\t\t\t\tvalue: aParams[0]\n\t\t\t};\n\t\t} else if (aParams[0] === \"ClearFieldValue\") {\n\t\t\tvalue = \"\";\n\t\t\tvalue = MassEditHandlers._getValueOnEmpty(oSource, fieldsInfoModel, value, sPropertyName);\n\t\t\toDataObject = {\n\t\t\t\tkeyValue: aParams[1],\n\t\t\t\tvalue: value\n\t\t\t};\n\t\t} else if (!aParams) {\n\t\t\tvalue = MassEditHandlers._getValueOnEmpty(oSource, fieldsInfoModel, value, sPropertyName);\n\t\t\toDataObject = {\n\t\t\t\tkeyValue: sPropertyName,\n\t\t\t\tvalue: value\n\t\t\t};\n\t\t} else {\n\t\t\tconst propertyName = aParams.slice(0, -1).join(\"/\");\n\t\t\tconst propertyValues =\n\t\t\t\tfieldsInfoModel.getProperty(\"/values/\" + propertyName) || fieldsInfoModel.getProperty(\"/unitData/\" + propertyName) || [];\n\n\t\t\tconst relatedField = (propertyValues || []).find(function (oFieldData: any) {\n\t\t\t\treturn oFieldData?.textInfo?.value === value || oFieldData.text === value;\n\t\t\t});\n\t\t\toDataObject = {\n\t\t\t\tkeyValue: propertyName,\n\t\t\t\tvalue:\n\t\t\t\t\trelatedField.textInfo && MassEditHandlers._valueExists(relatedField.textInfo.value)\n\t\t\t\t\t\t? relatedField.textInfo.value\n\t\t\t\t\t\t: relatedField.text\n\t\t\t};\n\t\t}\n\t\tlet bExistingElementindex = -1;\n\t\tfor (let i = 0; i < oFieldsInfoData.results.length; i++) {\n\t\t\tif (oFieldsInfoData.results[i].keyValue === oDataObject.keyValue) {\n\t\t\t\tbExistingElementindex = i;\n\t\t\t}\n\t\t}\n\t\tif (bExistingElementindex !== -1) {\n\t\t\toFieldsInfoData.results[bExistingElementindex] = oDataObject;\n\t\t} else {\n\t\t\toFieldsInfoData.results.push(oDataObject);\n\t\t}\n\t\tif (updateTransCtx) {\n\t\t\tconst transCtx = oSource.getBindingContext();\n\t\t\tif (aParams[0] === \"Default\" || aParams[0] === \"ClearFieldValue\") {\n\t\t\t\ttransCtx.setProperty(oDataObject.keyValue, null);\n\t\t\t} else if (oDataObject) {\n\t\t\t\ttransCtx.setProperty(oDataObject.keyValue, oDataObject.value);\n\t\t\t}\n\t\t}\n\t}\n};\n\nexport default MassEditHandlers;\n"]}