@sapui5/sap.fe.core 1.110.0 → 1.111.0

package/src/sap/fe/core/helpers/MassEditHelper-dbg.js

@@ -0,0 +1,1229 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/Log", "sap/fe/core/CommonUtils", "sap/fe/core/helpers/BindingToolkit", "sap/fe/core/library", "sap/fe/core/TemplateModel", "sap/fe/core/templating/DataModelPathHelper", "sap/fe/core/templating/PropertyHelper", "sap/fe/macros/field/FieldHelper", "sap/fe/macros/field/FieldTemplating", "sap/fe/macros/table/TableHelper", "sap/m/Button", "sap/m/Dialog", "sap/m/MessageToast", "sap/ui/core/Core", "sap/ui/core/Fragment", "sap/ui/core/util/XMLPreprocessor", "sap/ui/core/XMLTemplateProcessor", "sap/ui/mdc/enum/EditMode", "sap/ui/model/json/JSONModel", "../controllerextensions/messageHandler/messageHandling", "../controls/Any", "../converters/MetaModelConverter", "../templating/FieldControlHelper", "../templating/UIFormatters", "./SideEffectsHelper"], function (Log, CommonUtils, BindingToolkit, FELibrary, TemplateModel, DataModelPathHelper, PropertyHelper, FieldHelper, FieldTemplating, TableHelper, Button, Dialog, MessageToast, Core, Fragment, XMLPreprocessor, XMLTemplateProcessor, EditMode, JSONModel, messageHandling, Any, MetaModelConverter, FieldControlHelper, UIFormatters, SideEffectsHelper) {
+  "use strict";
+
+  var isMultiValueField = UIFormatters.isMultiValueField;
+  var getRequiredExpression = UIFormatters.getRequiredExpression;
+  var getEditMode = UIFormatters.getEditMode;
+  var isReadOnlyExpression = FieldControlHelper.isReadOnlyExpression;
+  var getInvolvedDataModelObjects = MetaModelConverter.getInvolvedDataModelObjects;
+  var convertMetaModelContext = MetaModelConverter.convertMetaModelContext;
+  var setEditStyleProperties = FieldTemplating.setEditStyleProperties;
+  var getTextBinding = FieldTemplating.getTextBinding;
+  var hasValueHelpWithFixedValues = PropertyHelper.hasValueHelpWithFixedValues;
+  var hasValueHelp = PropertyHelper.hasValueHelp;
+  var hasUnit = PropertyHelper.hasUnit;
+  var hasCurrency = PropertyHelper.hasCurrency;
+  var getAssociatedUnitPropertyPath = PropertyHelper.getAssociatedUnitPropertyPath;
+  var getAssociatedUnitProperty = PropertyHelper.getAssociatedUnitProperty;
+  var getRelativePaths = DataModelPathHelper.getRelativePaths;
+  var enhanceDataModelPath = DataModelPathHelper.enhanceDataModelPath;
+  var pathInModel = BindingToolkit.pathInModel;
+  var or = BindingToolkit.or;
+  var not = BindingToolkit.not;
+  var ifElse = BindingToolkit.ifElse;
+  var constant = BindingToolkit.constant;
+  var compileExpression = BindingToolkit.compileExpression;
+  const MassEditHelper = {
+    /**
+     * Initializes the value at final or deepest level path with a blank array.
+     * Return an empty array pointing to the final or deepest level path.
+     *
+     * @param sPath Property path
+     * @param aValues Array instance where the default data needs to be added
+     * @returns The final path
+     */
+    initLastLevelOfPropertyPath: function (sPath, aValues) {
+      let aFinalPath;
+      let index = 0;
+      const aPaths = sPath.split("/");
+      let sFullPath = "";
+      aPaths.forEach(function (sPropertyPath) {
+        if (!aValues[sPropertyPath] && index === 0) {
+          aValues[sPropertyPath] = {};
+          aFinalPath = aValues[sPropertyPath];
+          sFullPath = sFullPath + sPropertyPath;
+          index++;
+        } else if (!aFinalPath[sPropertyPath]) {
+          sFullPath = `${sFullPath}/${sPropertyPath}`;
+          if (sFullPath !== sPath) {
+            aFinalPath[sPropertyPath] = {};
+            aFinalPath = aFinalPath[sPropertyPath];
+          } else {
+            aFinalPath[sPropertyPath] = [];
+          }
+        }
+      });
+      return aFinalPath;
+    },
+    /**
+     * Method to get unique values for given array values.
+     *
+     * @param sValue Property value
+     * @param index Index of the property value
+     * @param self Instance of the array
+     * @returns The unique value
+     */
+    getUniqueValues: function (sValue, index, self) {
+      return sValue != undefined && sValue != null ? self.indexOf(sValue) === index : undefined;
+    },
+    /**
+     * Gets the property value for a multi-level path (for example: _Materials/Material_Details gets the value of Material_Details under _Materials Object).
+     * Returns the propertyValue, which can be of any type (string, number, etc..).
+     *
+     * @param sDataPropertyPath Property path
+     * @param oValues Object of property values
+     * @returns The property value
+     */
+    getValueForMultiLevelPath: function (sDataPropertyPath, oValues) {
+      let result;
+      if (sDataPropertyPath && sDataPropertyPath.indexOf("/") > 0) {
+        const aPropertyPaths = sDataPropertyPath.split("/");
+        aPropertyPaths.forEach(function (sPath) {
+          result = oValues && oValues[sPath] ? oValues[sPath] : result && result[sPath];
+        });
+      }
+      return result;
+    },
+    /**
+     * Gets the key path for the key of a combo box that must be selected initially when the dialog opens:
+     * => If propertyValue for all selected contexts is different, then < Keep Existing Values > is preselected.
+     * => If propertyValue for all selected contexts is the same, then the propertyValue is preselected.
+     * => If propertyValue for all selected contexts is empty, then < Leave Blank > is preselected.
+     *
+     *
+     * @param aContexts Contexts for mass edit
+     * @param sDataPropertyPath Data property path
+     * @returns The key path
+     */
+    getDefaultSelectionPathComboBox: function (aContexts, sDataPropertyPath) {
+      let result;
+      if (sDataPropertyPath && aContexts.length > 0) {
+        const oSelectedContext = aContexts,
+          aPropertyValues = [];
+        oSelectedContext.forEach(function (oContext) {
+          const oDataObject = oContext.getObject();
+          const sMultiLevelPathCondition = sDataPropertyPath.indexOf("/") > -1 && oDataObject.hasOwnProperty(sDataPropertyPath.split("/")[0]);
+          if (oContext && (oDataObject.hasOwnProperty(sDataPropertyPath) || sMultiLevelPathCondition)) {
+            aPropertyValues.push(oContext.getObject(sDataPropertyPath));
+          }
+        });
+        const aUniquePropertyValues = aPropertyValues.filter(MassEditHelper.getUniqueValues);
+        if (aUniquePropertyValues.length > 1) {
+          result = `Default/${sDataPropertyPath}`;
+        } else if (aUniquePropertyValues.length === 0) {
+          result = `Empty/${sDataPropertyPath}`;
+        } else if (aUniquePropertyValues.length === 1) {
+          result = `${sDataPropertyPath}/${aUniquePropertyValues[0]}`;
+        }
+      }
+      return result;
+    },
+    /**
+     * Checks hidden annotation value [both static and path based] for table's selected context.
+     *
+     * @param hiddenValue Hidden annotation value / path for field
+     * @param aContexts Contexts for mass edit
+     * @returns The hidden annotation value
+     */
+    getHiddenValueForContexts: function (hiddenValue, aContexts) {
+      if (hiddenValue && hiddenValue.$Path) {
+        return !aContexts.some(function (oSelectedContext) {
+          return oSelectedContext.getObject(hiddenValue.$Path) === false;
+        });
+      }
+      return hiddenValue;
+    },
+    getInputType: function (propertyInfo, dataFieldConverted, oDataModelPath) {
+      const editStyleProperties = {};
+      let inputType;
+      if (propertyInfo) {
+        setEditStyleProperties(editStyleProperties, dataFieldConverted, oDataModelPath, true);
+        inputType = (editStyleProperties === null || editStyleProperties === void 0 ? void 0 : editStyleProperties.editStyle) || "";
+      }
+      const isValidForMassEdit = inputType && ["DatePicker", "TimePicker", "DateTimePicker", "RatingIndicator"].indexOf(inputType) === -1 && !isMultiValueField(oDataModelPath) && !hasValueHelpWithFixedValues(propertyInfo);
+      return (isValidForMassEdit || "") && inputType;
+    },
+    getIsFieldGrp: function (dataFieldConverted) {
+      return dataFieldConverted && dataFieldConverted.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAnnotation" && dataFieldConverted.Target && dataFieldConverted.Target.value && dataFieldConverted.Target.value.indexOf("FieldGroup") > -1;
+    },
+    /**
+     * Get text path for the mass edit field.
+     *
+     * @param property Property path
+     * @param textBinding Text Binding Info
+     * @param displayMode Display mode
+     * @returns Text Property Path if it exists
+     */
+    getTextPath: function (property, textBinding, displayMode) {
+      let descriptionPath;
+      if (textBinding && (textBinding.path || textBinding.parameters && textBinding.parameters.length) && property) {
+        if (textBinding.path && displayMode === "Description") {
+          descriptionPath = textBinding.path;
+        } else if (textBinding.parameters) {
+          textBinding.parameters.forEach(function (props) {
+            if (props.path && props.path !== property) {
+              descriptionPath = props.path;
+            }
+          });
+        }
+      }
+      return descriptionPath;
+    },
+    /**
+     * Initializes a JSON Model for properties of dialog fields [label, visiblity, dataproperty, etc.].
+     *
+     * @param oTable Instance of Table
+     * @param aContexts Contexts for mass edit
+     * @param aDataArray Array containing data related to the dialog used by both the static and the runtime model
+     * @returns The model
+     */
+    prepareDataForDialog: function (oTable, aContexts, aDataArray) {
+      const oMetaModel = oTable && oTable.getModel().getMetaModel(),
+        sCurrentEntitySetName = oTable.data("metaPath"),
+        aTableFields = MassEditHelper.getTableFields(oTable),
+        oEntityTypeContext = oMetaModel.getContext(`${sCurrentEntitySetName}/@`),
+        oEntitySetContext = oMetaModel.getContext(sCurrentEntitySetName),
+        oDataModelObjectPath = getInvolvedDataModelObjects(oEntityTypeContext);
+      const oDataFieldModel = new JSONModel();
+      let oResult;
+      let sLabelText;
+      let bValueHelpEnabled;
+      let sUnitPropertyPath;
+      let bValueHelpEnabledForUnit;
+      let oTextBinding;
+      aTableFields.forEach(function (oColumnInfo) {
+        const sDataPropertyPath = oColumnInfo.dataProperty;
+        if (sDataPropertyPath) {
+          var _oDataFieldConverted$, _oDataFieldConverted$2, _oPropertyInfo, _oPropertyInfo$annota, _oPropertyInfo$annota2, _unitPropertyInfo$ann, _unitPropertyInfo$ann2;
+          let oPropertyInfo = sDataPropertyPath && oMetaModel.getObject(`${sCurrentEntitySetName}/${sDataPropertyPath}@`);
+          sLabelText = oColumnInfo.label || oPropertyInfo && oPropertyInfo["@com.sap.vocabularies.Common.v1.Label"] || sDataPropertyPath;
+          if (oDataModelObjectPath) {
+            oDataModelObjectPath.targetObject = oDataModelObjectPath.targetEntityType.entityProperties.filter(function (oProperty) {
+              return oProperty.name === sDataPropertyPath;
+            });
+          }
+          oDataModelObjectPath.targetObject = oDataModelObjectPath.targetObject[0] || {};
+          oTextBinding = getTextBinding(oDataModelObjectPath, {}, true) || {};
+          const oFieldContext = oMetaModel.getContext(oColumnInfo.annotationPath),
+            oDataFieldConverted = convertMetaModelContext(oFieldContext),
+            oPropertyContext = oMetaModel.getContext(`${sCurrentEntitySetName}/${sDataPropertyPath}@`),
+            oInterface = oPropertyContext && oPropertyContext.getInterface();
+          let oDataModelPath = getInvolvedDataModelObjects(oFieldContext, oEntitySetContext);
+          if ((oDataFieldConverted === null || oDataFieldConverted === void 0 ? void 0 : (_oDataFieldConverted$ = oDataFieldConverted.Value) === null || _oDataFieldConverted$ === void 0 ? void 0 : (_oDataFieldConverted$2 = _oDataFieldConverted$.path) === null || _oDataFieldConverted$2 === void 0 ? void 0 : _oDataFieldConverted$2.length) > 0) {
+            oDataModelPath = enhanceDataModelPath(oDataModelPath, sDataPropertyPath);
+          }
+          const bHiddenField = MassEditHelper.getHiddenValueForContexts(oFieldContext && oFieldContext.getObject()["@com.sap.vocabularies.UI.v1.Hidden"], aContexts) || false;
+          const isImage = oPropertyInfo && oPropertyInfo["@com.sap.vocabularies.UI.v1.IsImageURL"];
+          oInterface.context = {
+            getModel: function () {
+              return oInterface.getModel();
+            },
+            getPath: function () {
+              return `${sCurrentEntitySetName}/${sDataPropertyPath}`;
+            }
+          };
+          oPropertyInfo = oDataFieldConverted._type === "Property" ? oDataFieldConverted : oDataFieldConverted && oDataFieldConverted.Value && oDataFieldConverted.Value.$target || oDataFieldConverted && oDataFieldConverted.Target && oDataFieldConverted.Target.$target;
+          // Datafield is not included in the FieldControl calculation, needs to be implemented
+
+          const chartProperty = oPropertyInfo && oPropertyInfo.term && oPropertyInfo.term === "com.sap.vocabularies.UI.v1.Chart";
+          const isAction = !!oDataFieldConverted.Action;
+          const isFieldGrp = MassEditHelper.getIsFieldGrp(oDataFieldConverted);
+          if (isImage || bHiddenField || chartProperty || isAction || isFieldGrp) {
+            return;
+          }
+
+          // ValueHelp properties
+          sUnitPropertyPath = (hasCurrency(oPropertyInfo) || hasUnit(oPropertyInfo)) && getAssociatedUnitPropertyPath(oPropertyInfo) || "";
+          const unitPropertyInfo = sUnitPropertyPath && getAssociatedUnitProperty(oPropertyInfo);
+          bValueHelpEnabled = hasValueHelp(oPropertyInfo);
+          bValueHelpEnabledForUnit = unitPropertyInfo && hasValueHelp(unitPropertyInfo);
+          const hasContextDependentVH = (bValueHelpEnabled || bValueHelpEnabledForUnit) && (((_oPropertyInfo = oPropertyInfo) === null || _oPropertyInfo === void 0 ? void 0 : (_oPropertyInfo$annota = _oPropertyInfo.annotations) === null || _oPropertyInfo$annota === void 0 ? void 0 : (_oPropertyInfo$annota2 = _oPropertyInfo$annota.Common) === null || _oPropertyInfo$annota2 === void 0 ? void 0 : _oPropertyInfo$annota2.ValueListRelevantQualifiers) || unitPropertyInfo && (unitPropertyInfo === null || unitPropertyInfo === void 0 ? void 0 : (_unitPropertyInfo$ann = unitPropertyInfo.annotations) === null || _unitPropertyInfo$ann === void 0 ? void 0 : (_unitPropertyInfo$ann2 = _unitPropertyInfo$ann.Common) === null || _unitPropertyInfo$ann2 === void 0 ? void 0 : _unitPropertyInfo$ann2.ValueListRelevantQualifiers));
+          if (hasContextDependentVH) {
+            // context dependent VH is not supported for Mass Edit.
+            return;
+          }
+
+          // EditMode and InputType
+          const propertyForFieldControl = oPropertyInfo && oPropertyInfo.Value ? oPropertyInfo.Value : oPropertyInfo;
+          const expBinding = getEditMode(propertyForFieldControl, oDataModelPath, false, false, oDataFieldConverted, constant(true));
+          const editModeValues = Object.keys(EditMode);
+          const editModeIsStatic = !!expBinding && editModeValues.includes(expBinding);
+          const editable = !!expBinding && (editModeIsStatic && expBinding === EditMode.Editable || !editModeIsStatic);
+          const navPropertyWithValueHelp = sDataPropertyPath.includes("/") && bValueHelpEnabled;
+          if (!editable || navPropertyWithValueHelp) {
+            return;
+          }
+          const inputType = MassEditHelper.getInputType(oPropertyInfo, oDataFieldConverted, oDataModelPath);
+          if (inputType) {
+            const relativePath = getRelativePaths(oDataModelPath);
+            const isReadOnly = isReadOnlyExpression(oPropertyInfo, relativePath);
+            const displayMode = CommonUtils.computeDisplayMode(oPropertyContext.getObject());
+            const isValueHelpEnabled = bValueHelpEnabled ? bValueHelpEnabled : false;
+            const isValueHelpEnabledForUnit = bValueHelpEnabledForUnit && !sUnitPropertyPath.includes("/") ? bValueHelpEnabledForUnit : false;
+            const unitProperty = sUnitPropertyPath && !sDataPropertyPath.includes("/") ? sUnitPropertyPath : false;
+            oResult = {
+              label: sLabelText,
+              dataProperty: sDataPropertyPath,
+              isValueHelpEnabled: bValueHelpEnabled ? bValueHelpEnabled : false,
+              unitProperty,
+              isFieldRequired: getRequiredExpression(oPropertyInfo, oDataFieldConverted, true, false, {}, oDataModelPath),
+              defaultSelectionPath: sDataPropertyPath ? MassEditHelper.getDefaultSelectionPathComboBox(aContexts, sDataPropertyPath) : false,
+              defaultSelectionUnitPath: sUnitPropertyPath ? MassEditHelper.getDefaultSelectionPathComboBox(aContexts, sUnitPropertyPath) : false,
+              entitySet: sCurrentEntitySetName,
+              display: displayMode,
+              descriptionPath: MassEditHelper.getTextPath(sDataPropertyPath, oTextBinding, displayMode),
+              nullable: oPropertyInfo.nullable !== undefined ? oPropertyInfo.nullable : true,
+              isPropertyReadOnly: isReadOnly !== undefined ? isReadOnly : false,
+              inputType: inputType,
+              editMode: editable ? expBinding : undefined,
+              propertyInfo: {
+                hasVH: isValueHelpEnabled,
+                runtimePath: "fieldsInfo>/values/",
+                relativePath: sDataPropertyPath,
+                propertyPathForValueHelp: `${sCurrentEntitySetName}/${sDataPropertyPath}`
+              },
+              unitInfo: unitProperty && {
+                hasVH: isValueHelpEnabledForUnit,
+                runtimePath: "fieldsInfo>/unitData/",
+                relativePath: unitProperty,
+                propertyPathForValueHelp: `${sCurrentEntitySetName}/${unitProperty}`
+              }
+            };
+            aDataArray.push(oResult);
+          }
+        }
+      });
+      oDataFieldModel.setData(aDataArray);
+      return oDataFieldModel;
+    },
+    getTableFields: function (oTable) {
+      const aColumns = oTable && oTable.getColumns() || [];
+      const columnsData = oTable && oTable.getParent().getTableDefinition().columns;
+      return aColumns.map(function (oColumn) {
+        const sDataProperty = oColumn && oColumn.getDataProperty(),
+          aRealtedColumnInfo = columnsData && columnsData.filter(function (oColumnInfo) {
+            return oColumnInfo.name === sDataProperty && oColumnInfo.type === "Annotation";
+          });
+        return {
+          dataProperty: sDataProperty,
+          label: oColumn.getHeader(),
+          annotationPath: aRealtedColumnInfo && aRealtedColumnInfo[0] && aRealtedColumnInfo[0].annotationPath
+        };
+      });
+    },
+    getDefaultTextsForDialog: function (oResourceBundle, iSelectedContexts, oTable) {
+      // The confirm button text is "Save" for table in Display mode and "Apply" for table in edit mode. This can be later exposed if needed.
+      const bDisplayMode = oTable.data("displayModePropertyBinding") === "true";
+      return {
+        keepExistingPrefix: "< Keep",
+        leaveBlankValue: "< Leave Blank >",
+        clearFieldValue: "< Clear Values >",
+        massEditTitle: oResourceBundle.getText("C_MASS_EDIT_DIALOG_TITLE", iSelectedContexts.toString()),
+        applyButtonText: bDisplayMode ? oResourceBundle.getText("C_MASS_EDIT_SAVE_BUTTON_TEXT") : oResourceBundle.getText("C_MASS_EDIT_APPLY_BUTTON_TEXT"),
+        useValueHelpValue: "< Use Value Help >",
+        cancelButtonText: oResourceBundle.getText("C_COMMON_OBJECT_PAGE_CANCEL"),
+        noFields: oResourceBundle.getText("C_MASS_EDIT_NO_EDITABLE_FIELDS"),
+        okButtonText: oResourceBundle.getText("C_COMMON_DIALOG_OK")
+      };
+    },
+    /**
+     * Adds a suffix to the 'keep existing' property of the comboBox.
+     *
+     * @param sInputType InputType of the field
+     * @returns The modified string
+     */
+    // getSuffixForKeepExisiting: function (sInputType: string) {
+    // 	let sResult = "Values";
+
+    // 	switch (sInputType) {
+    // 		//TODO - Add for other control types as well (Radio Button, Email, Input, MDC Fields, Image etc.)
+    // 		case "DatePicker":
+    // 			sResult = "Dates";
+    // 			break;
+    // 		case "CheckBox":
+    // 			sResult = "Settings";
+    // 			break;
+    // 		default:
+    // 			sResult = "Values";
+    // 	}
+    // 	return sResult;
+    // },
+
+    /**
+     * Adds default values to the model [Keep Existing Values, Leave Blank].
+     *
+     * @param aValues Array instance where the default data needs to be added
+     * @param oDefaultValues Default values from Application Manifest
+     * @param oPropertyInfo Property information
+     * @param bUOMField
+     */
+    setDefaultValuesToDialog: function (aValues, oDefaultValues, oPropertyInfo, bUOMField) {
+      const sPropertyPath = bUOMField ? oPropertyInfo.unitProperty : oPropertyInfo.dataProperty,
+        sInputType = oPropertyInfo.inputType,
+        bPropertyRequired = oPropertyInfo.isFieldRequired;
+      // const sSuffixForKeepExisting = MassEditHelper.getSuffixForKeepExisiting(sInputType);
+      const sSuffixForKeepExisting = "Values";
+      aValues.defaultOptions = aValues.defaultOptions || [];
+      const selectOptionsExist = aValues.selectOptions && aValues.selectOptions.length > 0;
+      const keepEntry = {
+        text: `${oDefaultValues.keepExistingPrefix} ${sSuffixForKeepExisting} >`,
+        key: `Default/${sPropertyPath}`
+      };
+      if (sInputType === "CheckBox") {
+        const falseEntry = {
+          text: "No",
+          key: `${sPropertyPath}/false`,
+          textInfo: {
+            value: false
+          }
+        };
+        const truthyEntry = {
+          text: "Yes",
+          key: `${sPropertyPath}/true`,
+          textInfo: {
+            value: true
+          }
+        };
+        aValues.unshift(falseEntry);
+        aValues.defaultOptions.unshift(falseEntry);
+        aValues.unshift(truthyEntry);
+        aValues.defaultOptions.unshift(truthyEntry);
+        aValues.unshift(keepEntry);
+        aValues.defaultOptions.unshift(keepEntry);
+      } else {
+        var _oPropertyInfo$proper, _oPropertyInfo$unitIn;
+        if (oPropertyInfo !== null && oPropertyInfo !== void 0 && (_oPropertyInfo$proper = oPropertyInfo.propertyInfo) !== null && _oPropertyInfo$proper !== void 0 && _oPropertyInfo$proper.hasVH || oPropertyInfo !== null && oPropertyInfo !== void 0 && (_oPropertyInfo$unitIn = oPropertyInfo.unitInfo) !== null && _oPropertyInfo$unitIn !== void 0 && _oPropertyInfo$unitIn.hasVH && bUOMField) {
+          const vhdEntry = {
+            text: oDefaultValues.useValueHelpValue,
+            key: `UseValueHelpValue/${sPropertyPath}`
+          };
+          aValues.unshift(vhdEntry);
+          aValues.defaultOptions.unshift(vhdEntry);
+        }
+        if (selectOptionsExist) {
+          if (bPropertyRequired !== "true" && !bUOMField) {
+            const clearEntry = {
+              text: oDefaultValues.clearFieldValue,
+              key: `ClearFieldValue/${sPropertyPath}`
+            };
+            aValues.unshift(clearEntry);
+            aValues.defaultOptions.unshift(clearEntry);
+          }
+          aValues.unshift(keepEntry);
+          aValues.defaultOptions.unshift(keepEntry);
+        } else {
+          const emptyEntry = {
+            text: oDefaultValues.leaveBlankValue,
+            key: `Default/${sPropertyPath}`
+          };
+          aValues.unshift(emptyEntry);
+          aValues.defaultOptions.unshift(emptyEntry);
+        }
+      }
+    },
+    /**
+     * Get text arrangement info for a context property.
+     *
+     * @param property Property Path
+     * @param descriptionPath Path to text association of the property
+     * @param displayMode Display mode of the property and text association
+     * @param selectedContext Context to find the full text
+     * @returns The text arrangement
+     */
+    getTextArrangementInfo: function (property, descriptionPath, displayMode, selectedContext) {
+      let value = selectedContext.getObject(property),
+        descriptionValue,
+        fullText;
+      if (descriptionPath && property) {
+        switch (displayMode) {
+          case "Description":
+            descriptionValue = selectedContext.getObject(descriptionPath) || "";
+            fullText = descriptionValue;
+            break;
+          case "Value":
+            value = selectedContext.getObject(property) || "";
+            fullText = value;
+            break;
+          case "ValueDescription":
+            value = selectedContext.getObject(property) || "";
+            descriptionValue = selectedContext.getObject(descriptionPath) || "";
+            fullText = descriptionValue ? `${value} (${descriptionValue})` : value;
+            break;
+          case "DescriptionValue":
+            value = selectedContext.getObject(property) || "";
+            descriptionValue = selectedContext.getObject(descriptionPath) || "";
+            fullText = descriptionValue ? `${descriptionValue} (${value})` : value;
+            break;
+          default:
+            Log.info(`Display Property not applicable: ${property}`);
+            break;
+        }
+      }
+      return {
+        textArrangement: displayMode,
+        valuePath: property,
+        descriptionPath: descriptionPath,
+        value: value,
+        description: descriptionValue,
+        fullText: fullText
+      };
+    },
+    /**
+     * Return the visibility valuue for the ManagedObject Any.
+     *
+     * @param any The ManagedObject Any to be used to calculate the visible value of the binding.
+     * @returns Returns true if the mass edit field is editable.
+     */
+    isEditable: function (any) {
+      const binding = any.getBinding("any");
+      const value = binding.getExternalValue();
+      return value === EditMode.Editable;
+    },
+    /**
+     * Calculate and update the visibility of mass edit field on change of the ManagedObject Any binding.
+     *
+     * @param oDialogDataModel Model to be used runtime.
+     * @param dataProperty Field name.
+     */
+    onContextEditableChange: function (oDialogDataModel, dataProperty) {
+      const objectsForVisibility = oDialogDataModel.getProperty(`/values/${dataProperty}/objectsForVisibility`) || [];
+      const editable = objectsForVisibility.some(MassEditHelper.isEditable);
+      if (editable) {
+        oDialogDataModel.setProperty(`/values/${dataProperty}/visible`, editable);
+      }
+    },
+    /**
+     * Update Managed Object Any for visibility of the mass edit fields.
+     *
+     * @param mOToUse The ManagedObject Any to be used to calculate the visible value of the binding.
+     * @param oDialogDataModel Model to be used runtime.
+     * @param dataProperty Field name.
+     * @param values Values of the field.
+     */
+    updateOnContextChange: function (mOToUse, oDialogDataModel, dataProperty, values) {
+      const binding = mOToUse.getBinding("any");
+      values.objectsForVisibility = values.objectsForVisibility || [];
+      values.objectsForVisibility.push(mOToUse);
+      binding === null || binding === void 0 ? void 0 : binding.attachChange(MassEditHelper.onContextEditableChange.bind(null, oDialogDataModel, dataProperty));
+    },
+    /**
+     * Get bound object to calculate the visibility of contexts.
+     *
+     * @param expBinding Binding String object.
+     * @param context Context the binding value.
+     * @returns The ManagedObject Any to be used to calculate the visible value of the binding.
+     */
+    getBoundObject: function (expBinding, context) {
+      const mOToUse = new Any({
+        any: expBinding
+      });
+      const model = context.getModel();
+      mOToUse.setModel(model);
+      mOToUse.setBindingContext(context);
+      return mOToUse;
+    },
+    /**
+     * Get the visibility of the field.
+     *
+     * @param expBinding Binding String object.
+     * @param oDialogDataModel Model to be used runtime.
+     * @param dataProperty Field name.
+     * @param values Values of the field.
+     * @param context Context the binding value.
+     * @returns Returns true if the mass edit field is editable.
+     */
+    getFieldVisiblity: function (expBinding, oDialogDataModel, dataProperty, values, context) {
+      const mOToUse = MassEditHelper.getBoundObject(expBinding, context);
+      const isContextEditable = MassEditHelper.isEditable(mOToUse);
+      if (!isContextEditable) {
+        MassEditHelper.updateOnContextChange(mOToUse, oDialogDataModel, dataProperty, values);
+      }
+      return isContextEditable;
+    },
+    /**
+     * Initializes a runtime model:
+     * => The model consists of values shown in the comboBox of the dialog (Leave Blank, Keep Existing Values, or any property value for the selected context, etc.)
+     * => The model will capture runtime changes in the results property (the value entered in the comboBox).
+     *
+     * @param aContexts Contexts for mass edit
+     * @param aDataArray Array containing data related to the dialog used by both the static and the runtime model
+     * @param oDefaultValues Default values from i18n
+     * @param dialogContext Transient context for mass edit dialog.
+     * @returns The runtime model
+     */
+    setRuntimeModelOnDialog: function (aContexts, aDataArray, oDefaultValues, dialogContext) {
+      const aValues = [];
+      const aUnitData = [];
+      const aResults = [];
+      const textPaths = [];
+      const aReadOnlyFieldInfo = [];
+      const oData = {
+        values: aValues,
+        unitData: aUnitData,
+        results: aResults,
+        readablePropertyData: aReadOnlyFieldInfo,
+        selectedKey: undefined,
+        textPaths: textPaths,
+        noFields: oDefaultValues.noFields
+      };
+      const oDialogDataModel = new JSONModel(oData);
+      aDataArray.forEach(function (oInData) {
+        let oTextInfo;
+        let sPropertyKey;
+        let sUnitPropertyName;
+        const oDistinctValueMap = {};
+        const oDistinctUnitMap = {};
+        if (oInData.dataProperty && oInData.dataProperty.indexOf("/") > -1) {
+          const aFinalPath = MassEditHelper.initLastLevelOfPropertyPath(oInData.dataProperty, aValues /*, dialogContext */);
+          const aPropertyPaths = oInData.dataProperty.split("/");
+          for (const context of aContexts) {
+            const sMultiLevelPathValue = context.getObject(oInData.dataProperty);
+            sPropertyKey = `${oInData.dataProperty}/${sMultiLevelPathValue}`;
+            if (!oDistinctValueMap[sPropertyKey] && aFinalPath[aPropertyPaths[aPropertyPaths.length - 1]]) {
+              oTextInfo = MassEditHelper.getTextArrangementInfo(oInData.dataProperty, oInData.descriptionPath, oInData.display, context);
+              aFinalPath[aPropertyPaths[aPropertyPaths.length - 1]].push({
+                text: oTextInfo && oTextInfo.fullText || sMultiLevelPathValue,
+                key: sPropertyKey,
+                textInfo: oTextInfo
+              });
+              oDistinctValueMap[sPropertyKey] = sMultiLevelPathValue;
+            }
+          }
+          // if (Object.keys(oDistinctValueMap).length === 1) {
+          // 	dialogContext.setProperty(oData.dataProperty, sPropertyKey && oDistinctValueMap[sPropertyKey]);
+          // }
+
+          aFinalPath[aPropertyPaths[aPropertyPaths.length - 1]].textInfo = {
+            descriptionPath: oInData.descriptionPath,
+            valuePath: oInData.dataProperty,
+            displayMode: oInData.display
+          };
+        } else {
+          aValues[oInData.dataProperty] = aValues[oInData.dataProperty] || [];
+          aValues[oInData.dataProperty]["selectOptions"] = aValues[oInData.dataProperty]["selectOptions"] || [];
+          if (oInData.unitProperty) {
+            aUnitData[oInData.unitProperty] = aUnitData[oInData.unitProperty] || [];
+            aUnitData[oInData.unitProperty]["selectOptions"] = aUnitData[oInData.unitProperty]["selectOptions"] || [];
+          }
+          for (const context of aContexts) {
+            const oDataObject = context.getObject();
+            sPropertyKey = `${oInData.dataProperty}/${oDataObject[oInData.dataProperty]}`;
+            if (oInData.dataProperty && oDataObject[oInData.dataProperty] && !oDistinctValueMap[sPropertyKey]) {
+              if (oInData.inputType != "CheckBox") {
+                oTextInfo = MassEditHelper.getTextArrangementInfo(oInData.dataProperty, oInData.descriptionPath, oInData.display, context);
+                const entry = {
+                  text: oTextInfo && oTextInfo.fullText || oDataObject[oInData.dataProperty],
+                  key: sPropertyKey,
+                  textInfo: oTextInfo
+                };
+                aValues[oInData.dataProperty].push(entry);
+                aValues[oInData.dataProperty]["selectOptions"].push(entry);
+              }
+              oDistinctValueMap[sPropertyKey] = oDataObject[oInData.dataProperty];
+            }
+            if (oInData.unitProperty && oDataObject[oInData.unitProperty]) {
+              sUnitPropertyName = `${oInData.unitProperty}/${oDataObject[oInData.unitProperty]}`;
+              if (!oDistinctUnitMap[sUnitPropertyName]) {
+                if (oInData.inputType != "CheckBox") {
+                  oTextInfo = MassEditHelper.getTextArrangementInfo(oInData.unitProperty, oInData.descriptionPath, oInData.display, context);
+                  const unitEntry = {
+                    text: oTextInfo && oTextInfo.fullText || oDataObject[oInData.unitProperty],
+                    key: sUnitPropertyName,
+                    textInfo: oTextInfo
+                  };
+                  aUnitData[oInData.unitProperty].push(unitEntry);
+                  aUnitData[oInData.unitProperty]["selectOptions"].push(unitEntry);
+                }
+                oDistinctUnitMap[sUnitPropertyName] = oDataObject[oInData.unitProperty];
+              }
+            }
+          }
+          aValues[oInData.dataProperty].textInfo = {
+            descriptionPath: oInData.descriptionPath,
+            valuePath: oInData.dataProperty,
+            displayMode: oInData.display
+          };
+          if (Object.keys(oDistinctValueMap).length === 1) {
+            dialogContext.setProperty(oInData.dataProperty, sPropertyKey && oDistinctValueMap[sPropertyKey]);
+          }
+          if (Object.keys(oDistinctUnitMap).length === 1) {
+            dialogContext.setProperty(oInData.unitProperty, sUnitPropertyName && oDistinctUnitMap[sUnitPropertyName]);
+          }
+        }
+        textPaths[oInData.dataProperty] = oInData.descriptionPath ? [oInData.descriptionPath] : [];
+      });
+      aDataArray.forEach(function (oInData) {
+        let values = {};
+        if (oInData.dataProperty.indexOf("/") > -1) {
+          const sMultiLevelPropPathValue = MassEditHelper.getValueForMultiLevelPath(oInData.dataProperty, aValues);
+          if (!sMultiLevelPropPathValue) {
+            sMultiLevelPropPathValue.push({
+              text: oDefaultValues.leaveBlankValue,
+              key: `Empty/${oInData.dataProperty}`
+            });
+          } else {
+            MassEditHelper.setDefaultValuesToDialog(sMultiLevelPropPathValue, oDefaultValues, oInData);
+          }
+          values = sMultiLevelPropPathValue;
+        } else if (aValues[oInData.dataProperty]) {
+          aValues[oInData.dataProperty] = aValues[oInData.dataProperty] || [];
+          MassEditHelper.setDefaultValuesToDialog(aValues[oInData.dataProperty], oDefaultValues, oInData);
+          values = aValues[oInData.dataProperty];
+        }
+        if (aUnitData[oInData.unitProperty] && aUnitData[oInData.unitProperty].length) {
+          MassEditHelper.setDefaultValuesToDialog(aUnitData[oInData.unitProperty], oDefaultValues, oInData, true);
+          aUnitData[oInData.unitProperty].textInfo = {};
+          aUnitData[oInData.unitProperty].selectedKey = MassEditHelper.getDefaultSelectionPathComboBox(aContexts, oInData.unitProperty);
+          aUnitData[oInData.unitProperty].inputType = oInData.inputType;
+        } else if (oInData.dataProperty && aValues[oInData.dataProperty] && !aValues[oInData.dataProperty].length || oInData.unitProperty && aUnitData[oInData.unitProperty] && !aUnitData[oInData.unitProperty].length) {
+          const bClearFieldOrBlankValueExists = aValues[oInData.dataProperty] && aValues[oInData.dataProperty].some(function (obj) {
+            return obj.text === "< Clear Values >" || obj.text === "< Leave Blank >";
+          });
+          if (oInData.dataProperty && !bClearFieldOrBlankValueExists) {
+            aValues[oInData.dataProperty].push({
+              text: oDefaultValues.leaveBlankValue,
+              key: `Empty/${oInData.dataProperty}`
+            });
+          }
+          const bClearFieldOrBlankUnitValueExists = aUnitData[oInData.unitProperty] && aUnitData[oInData.unitProperty].some(function (obj) {
+            return obj.text === "< Clear Values >" || obj.text === "< Leave Blank >";
+          });
+          if (oInData.unitProperty) {
+            if (!bClearFieldOrBlankUnitValueExists) {
+              aUnitData[oInData.unitProperty].push({
+                text: oDefaultValues.leaveBlankValue,
+                key: `Empty/${oInData.unitProperty}`
+              });
+            }
+            aUnitData[oInData.unitProperty].textInfo = {};
+            aUnitData[oInData.unitProperty].selectedKey = MassEditHelper.getDefaultSelectionPathComboBox(aContexts, oInData.unitProperty);
+            aUnitData[oInData.unitProperty].inputType = oInData.inputType;
+          }
+        }
+        if (oInData.isPropertyReadOnly && typeof oInData.isPropertyReadOnly === "boolean") {
+          aReadOnlyFieldInfo.push({
+            property: oInData.dataProperty,
+            value: oInData.isPropertyReadOnly,
+            type: "Default"
+          });
+        } else if (oInData.isPropertyReadOnly && oInData.isPropertyReadOnly.operands && oInData.isPropertyReadOnly.operands[0] && oInData.isPropertyReadOnly.operands[0].operand1 && oInData.isPropertyReadOnly.operands[0].operand2) {
+          // This needs to be refactored in accordance with the ReadOnlyExpression change
+          aReadOnlyFieldInfo.push({
+            property: oInData.dataProperty,
+            propertyPath: oInData.isPropertyReadOnly.operands[0].operand1.path,
+            propertyValue: oInData.isPropertyReadOnly.operands[0].operand2.value,
+            type: "Path"
+          });
+        }
+
+        // Setting visbility of the mass edit field.
+        if (oInData.editMode) {
+          values.visible = oInData.editMode === EditMode.Editable || aContexts.some(MassEditHelper.getFieldVisiblity.bind(MassEditHelper, oInData.editMode, oDialogDataModel, oInData.dataProperty, values));
+        } else {
+          values.visible = true;
+        }
+        values.selectedKey = MassEditHelper.getDefaultSelectionPathComboBox(aContexts, oInData.dataProperty);
+        values.inputType = oInData.inputType;
+        values.unitProperty = oInData.unitProperty;
+      });
+      return oDialogDataModel;
+    },
+    /**
+     * Gets transient context for dialog.
+     *
+     * @param table Instance of Table.
+     * @param dialog Mass Edit Dialog.
+     * @returns Promise returning instance of dialog.
+     */
+    getDialogContext: function (table, dialog) {
+      let transCtx = dialog && dialog.getBindingContext();
+      if (!transCtx) {
+        const model = table.getModel();
+        const listBinding = table.getRowBinding();
+        const transientListBinding = model.bindList(listBinding.getPath(), listBinding.getContext(), [], [], {
+          $$updateGroupId: "submitLater"
+        });
+        transientListBinding.refreshInternal = function () {
+          /* */
+        };
+        transCtx = transientListBinding.create({}, true);
+      }
+      return transCtx;
+    },
+    onDialogOpen: function (event) {
+      const source = event.getSource();
+      const fieldsInfoModel = source.getModel("fieldsInfo");
+      fieldsInfoModel.setProperty("/isOpen", true);
+    },
+    closeDialog: function (oDialog) {
+      oDialog.close();
+      oDialog.destroy();
+    },
+    messageHandlingForMassEdit: async function (oTable, aContexts, oController, oInDialog, aResults, errorContexts) {
+      var _oController$getView, _oController$getView$, _oController$getView4, _oController$getView5;
+      const DraftStatus = FELibrary.DraftStatus;
+      const oResourceBundle = Core.getLibraryResourceBundle("sap.fe.core");
+      (_oController$getView = oController.getView()) === null || _oController$getView === void 0 ? void 0 : (_oController$getView$ = _oController$getView.getBindingContext("internal")) === null || _oController$getView$ === void 0 ? void 0 : _oController$getView$.setProperty("getBoundMessagesForMassEdit", true);
+      oController._editFlow.getMessageHandler().showMessages({
+        onBeforeShowMessage: function (messages, showMessageParameters) {
+          //messages.concatenate(messageHandling.getMessages(true, true));
+          showMessageParameters.fnGetMessageSubtitle = messageHandling.setMessageSubtitle.bind({}, oTable, aContexts);
+          const unboundErrors = [];
+          messages.forEach(function (message) {
+            if (!message.getTarget()) {
+              unboundErrors.push(message);
+            }
+          });
+          if (aResults.length > 0 && errorContexts.length === 0) {
+            oController._editFlow.setDraftStatus(DraftStatus.Saved);
+            const successToast = oResourceBundle.getText("C_MASS_EDIT_SUCCESS_TOAST");
+            MessageToast.show(successToast);
+          } else if (errorContexts.length < oTable.getSelectedContexts().length) {
+            oController._editFlow.setDraftStatus(DraftStatus.Saved);
+          } else if (errorContexts.length === oTable.getSelectedContexts().length) {
+            oController._editFlow.setDraftStatus(DraftStatus.Clear);
+          }
+          if (oController.getModel("ui").getProperty("/isEditable") && unboundErrors.length === 0) {
+            showMessageParameters.showMessageBox = false;
+            showMessageParameters.showMessageDialog = false;
+          }
+          return showMessageParameters;
+        }
+      });
+      if (oInDialog.isOpen()) {
+        var _oController$getView2, _oController$getView3;
+        MassEditHelper.closeDialog(oInDialog);
+        (_oController$getView2 = oController.getView()) === null || _oController$getView2 === void 0 ? void 0 : (_oController$getView3 = _oController$getView2.getBindingContext("internal")) === null || _oController$getView3 === void 0 ? void 0 : _oController$getView3.setProperty("skipPatchHandlers", false);
+      }
+      (_oController$getView4 = oController.getView()) === null || _oController$getView4 === void 0 ? void 0 : (_oController$getView5 = _oController$getView4.getBindingContext("internal")) === null || _oController$getView5 === void 0 ? void 0 : _oController$getView5.setProperty("getBoundMessagesForMassEdit", false);
+    },
+    /**
+     * This function generates side effects map from side effects ids(which is a combination of entity type and qualifier).
+     *
+     * @param oEntitySetContext
+     * @param aSideEffects
+     * @param oController
+     * @param aResults
+     * @returns Side effect map with data.
+     */
+    getSideEffectDataForKey: function (oEntitySetContext, aSideEffects, oController, aResults) {
+      const sOwnerEntityType = oEntitySetContext.getProperty("$Type");
+      const baseSideEffectsMapArray = {};
+      aResults.forEach(result => {
+        const sPath = result.keyValue;
+        const sideEffectsArray = FieldHelper.getSideEffectsOnEntityAndProperty(sPath, sOwnerEntityType, aSideEffects);
+        baseSideEffectsMapArray[sPath] = oController._sideEffects.getSideEffectsMapForFieldGroups(sideEffectsArray);
+      });
+      return baseSideEffectsMapArray;
+    },
+    /**
+     * Give the entity type for a given spath for e.g.RequestedQuantity.
+     *
+     * @param sPath
+     * @param sEntityType
+     * @param oMetaModel
+     * @returns Object having entity, spath and navigation path.
+     */
+    fnGetPathForSourceProperty: function (sPath, sEntityType, oMetaModel) {
+      // if the property path has a navigation, get the target entity type of the navigation
+      const sNavigationPath = sPath.indexOf("/") > 0 ? "/" + sEntityType + "/" + sPath.substr(0, sPath.lastIndexOf("/") + 1) + "@sapui.name" : false,
+        pOwnerEntity = !sNavigationPath ? Promise.resolve(sEntityType) : oMetaModel.requestObject(sNavigationPath);
+      sPath = sNavigationPath ? sPath.substr(sPath.lastIndexOf("/") + 1) : sPath;
+      return {
+        sPath,
+        pOwnerEntity,
+        sNavigationPath
+      };
+    },
+    fnGetEntityTypeOfOwner: function (oMetaModel, baseNavPath, oEntitySetContext, targetEntity, aTargets) {
+      const ownerEntityType = oEntitySetContext.getProperty("$Type");
+      const {
+        $Type: pOwner,
+        $Partner: ownerNavPath
+      } = oMetaModel.getObject(`${oEntitySetContext}/${baseNavPath}`); // nav path
+      if (ownerNavPath) {
+        const entityObjOfOwnerPartner = oMetaModel.getObject(`/${pOwner}/${ownerNavPath}`);
+        if (entityObjOfOwnerPartner) {
+          const entityTypeOfOwnerPartner = entityObjOfOwnerPartner["$Type"];
+          // if the entity types defer, then base nav path is not from owner
+          if (entityTypeOfOwnerPartner !== ownerEntityType) {
+            // if target Prop is not from owner, we add it as immediate
+            aTargets.push(targetEntity);
+          }
+        }
+      } else {
+        // if there is no $Partner attribute, it may not be from owner
+        aTargets.push(targetEntity);
+      }
+      return aTargets;
+    },
+    /**
+     * Give targets that are immediate or deferred based on the entity type of that target.
+     *
+     *
+     * @param sideEffectsData
+     * @param oEntitySetContext
+     * @param sEntityType
+     * @param oMetaModel
+     * @returns Targets to request side effects.
+     */
+    fnGetTargetsForMassEdit: function (sideEffectsData, oEntitySetContext, sEntityType, oMetaModel) {
+      const {
+        TargetProperties: aTargetProperties,
+        TargetEntities: aTargetEntities
+      } = sideEffectsData;
+      const aPromises = [];
+      let aTargets = [];
+      const ownerEntityType = oEntitySetContext.getProperty("$Type");
+      if (sEntityType === ownerEntityType) {
+        // if SalesOrdr Item
+        aTargetEntities === null || aTargetEntities === void 0 ? void 0 : aTargetEntities.forEach(targetEntity => {
+          targetEntity = targetEntity["$NavigationPropertyPath"];
+          let baseNavPath;
+          if (targetEntity.includes("/")) {
+            baseNavPath = targetEntity.split("/")[0];
+          } else {
+            baseNavPath = targetEntity;
+          }
+          aTargets = MassEditHelper.fnGetEntityTypeOfOwner(oMetaModel, baseNavPath, oEntitySetContext, targetEntity, aTargets);
+        });
+      }
+      if (aTargetProperties.length) {
+        aTargetProperties.forEach(targetProp => {
+          const {
+            pOwnerEntity
+          } = MassEditHelper.fnGetPathForSourceProperty(targetProp, sEntityType, oMetaModel);
+          aPromises.push(pOwnerEntity.then(resultEntity => {
+            // if entity is SalesOrderItem, Target Property is from Items table
+            if (resultEntity === ownerEntityType) {
+              aTargets.push(targetProp); // get immediate targets
+            } else if (targetProp.includes("/")) {
+              const baseNavPath = targetProp.split("/")[0];
+              aTargets = MassEditHelper.fnGetEntityTypeOfOwner(oMetaModel, baseNavPath, oEntitySetContext, targetProp, aTargets);
+            }
+            return Promise.resolve(aTargets);
+          }));
+        });
+      } else {
+        aPromises.push(Promise.resolve(aTargets));
+      }
+      return Promise.all(aPromises);
+    },
+    /**
+     * This function checks if in the given side Effects Obj, if _Item is set as Target Entity for any side Effects on
+     * other entity set.
+     *
+     * @param sideEffectsMap
+     * @param oEntitySetContext
+     * @returns Length of sideEffectsArray where current Entity is set as Target Entity
+     */
+    checkIfEntityExistsAsTargetEntity: (sideEffectsMap, oEntitySetContext) => {
+      const ownerEntityType = oEntitySetContext.getProperty("$Type");
+      const sideEffectsOnOtherEntity = Object.values(sideEffectsMap).filter(obj => {
+        return obj.name.indexOf(ownerEntityType) == -1;
+      });
+      const entitySetName = oEntitySetContext.getPath().split("/").pop();
+      const sideEffectsWithCurrentEntityAsTarget = sideEffectsOnOtherEntity.filter(obj => {
+        const targetEntitiesArray = obj.sideEffects.TargetEntities;
+        return targetEntitiesArray !== null && targetEntitiesArray !== void 0 && targetEntitiesArray.filter(innerObj => innerObj["$NavigationPropertyPath"] === entitySetName).length ? obj : false;
+      });
+      return sideEffectsWithCurrentEntityAsTarget.length;
+    },
+    /**
+     * Upon updating the field, array of immediate and deferred side effects for that field are created.
+     * If there are any failed side effects for that context, they will also be used to generate the map.
+     * If the field has text associated with it, then add it to request side effects.
+     *
+     * @param mParams
+     * @param mParams.oController Controller
+     * @param mParams.oFieldPromise Promise to update field
+     * @param mParams.sideEffectMap SideEffectsMap for the field
+     * @param mParams.textPaths TextPaths of the field if any
+     * @param mParams.groupId Group Id to used to group requests
+     * @param mParams.key KeyValue of the field
+     * @param mParams.oEntitySetContext EntitySetcontext
+     * @param mParams.oMetaModel Metamodel data
+     * @param mParams.selectedContext Selected row context
+     * @param mParams.deferredTargetsForAQualifiedName Deferred targets data
+     * @returns Promise for all immediately requested side effects.
+     */
+    handleMassEditFieldUpdateAndRequestSideEffects: async function (mParams) {
+      const {
+        oController,
+        oFieldPromise,
+        sideEffectsMap,
+        textPaths,
+        groupId,
+        key,
+        oEntitySetContext,
+        oMetaModel,
+        oSelectedContext,
+        deferredTargetsForAQualifiedName
+      } = mParams;
+      const immediateSideEffectsPromises = [oFieldPromise];
+      const ownerEntityType = oEntitySetContext.getProperty("$Type");
+      const oAppComponent = CommonUtils.getAppComponent(oController.getView());
+      const oSideEffectsService = oAppComponent.getSideEffectsService();
+      const isSideEffectsWithCurrentEntityAsTarget = MassEditHelper.checkIfEntityExistsAsTargetEntity(sideEffectsMap, oEntitySetContext);
+      if (sideEffectsMap) {
+        const allEntityTypesWithQualifier = Object.keys(sideEffectsMap);
+        const sideEffectsDataForField = Object.values(sideEffectsMap);
+        const mVisitedSideEffects = {};
+        deferredTargetsForAQualifiedName[key] = {};
+        for (const [index, data] of sideEffectsDataForField.entries()) {
+          const entityTypeWithQualifier = allEntityTypesWithQualifier[index];
+          const sEntityType = entityTypeWithQualifier.split("#")[0];
+          const oContext = oController._sideEffects.getContextForSideEffects(oSelectedContext, sEntityType);
+          data.context = oContext;
+          const allFailedSideEffects = oController._sideEffects.getRegisteredFailedRequests();
+          const aFailedSideEffects = allFailedSideEffects[oContext.getPath()];
+          oController._sideEffects.unregisterFailedSideEffectsForAContext(oContext);
+          let sideEffectsForCurrentContext = [data.sideEffects];
+          sideEffectsForCurrentContext = aFailedSideEffects && aFailedSideEffects.length ? sideEffectsForCurrentContext.concat(aFailedSideEffects) : sideEffectsForCurrentContext;
+          mVisitedSideEffects[oContext] = {};
+          for (const aSideEffect of sideEffectsForCurrentContext) {
+            if (!mVisitedSideEffects[oContext].hasOwnProperty(aSideEffect.fullyQualifiedName)) {
+              mVisitedSideEffects[oContext][aSideEffect.fullyQualifiedName] = true;
+              let aImmediateTargets = [],
+                allTargets = [],
+                triggerActionName;
+              const fnGetImmediateTargetsAndActions = async function (mSideEffect) {
+                const {
+                  TargetProperties: aTargetProperties,
+                  TargetEntities: aTargetEntities
+                } = mSideEffect;
+                const sideEffectEntityType = mSideEffect.fullyQualifiedName.split("@")[0];
+                const targetsArrayForAllProperties = await MassEditHelper.fnGetTargetsForMassEdit(mSideEffect, oEntitySetContext, sideEffectEntityType, oMetaModel);
+                aImmediateTargets = targetsArrayForAllProperties[0];
+                allTargets = (aTargetProperties || []).concat(aTargetEntities || []);
+                const actionName = mSideEffect.TriggerAction;
+                const aDeferredTargets = allTargets.filter(target => {
+                  return !aImmediateTargets.includes(target);
+                });
+                deferredTargetsForAQualifiedName[key][mSideEffect.fullyQualifiedName] = {
+                  aTargets: aDeferredTargets,
+                  oContext: oContext,
+                  mSideEffect
+                };
+
+                // if entity is other than items table then action is defered
+                if (actionName && sideEffectEntityType === ownerEntityType) {
+                  // static action is on collection, so we defer it, else add to immediate requests array
+                  const isStaticAction = TableHelper._isStaticAction(oMetaModel.getObject(`/${actionName}`), actionName);
+                  if (!isStaticAction) {
+                    triggerActionName = actionName;
+                  } else {
+                    deferredTargetsForAQualifiedName[key][mSideEffect.fullyQualifiedName]["TriggerAction"] = actionName;
+                  }
+                } else {
+                  deferredTargetsForAQualifiedName[key][mSideEffect.fullyQualifiedName]["TriggerAction"] = actionName;
+                }
+                if (isSideEffectsWithCurrentEntityAsTarget) {
+                  aImmediateTargets = [];
+                }
+                return {
+                  aTargets: aImmediateTargets,
+                  TriggerAction: triggerActionName
+                };
+              };
+              immediateSideEffectsPromises.push(oController._sideEffects.requestSideEffects(aSideEffect, oContext, groupId, fnGetImmediateTargetsAndActions));
+            }
+          }
+        }
+      }
+      if (textPaths !== null && textPaths !== void 0 && textPaths[key] && textPaths[key].length) {
+        immediateSideEffectsPromises.push(oSideEffectsService.requestSideEffects(textPaths[key], oSelectedContext, groupId));
+      }
+      return Promise.allSettled(immediateSideEffectsPromises);
+    },
+    /**
+     * Create the mass edit dialog.
+     *
+     * @param oTable Instance of Table
+     * @param aContexts Contexts for mass edit
+     * @param oController Controller for the view
+     * @returns Promise returning instance of dialog.
+     */
+    createDialog: async function (oTable, aContexts, oController) {
+      const sFragmentName = "sap/fe/core/controls/massEdit/MassEditDialog",
+        aDataArray = [],
+        oResourceBundle = Core.getLibraryResourceBundle("sap.fe.core"),
+        oDefaultValues = MassEditHelper.getDefaultTextsForDialog(oResourceBundle, aContexts.length, oTable),
+        oDataFieldModel = MassEditHelper.prepareDataForDialog(oTable, aContexts, aDataArray),
+        dialogContext = MassEditHelper.getDialogContext(oTable),
+        oDialogDataModel = MassEditHelper.setRuntimeModelOnDialog(aContexts, aDataArray, oDefaultValues, dialogContext),
+        model = oTable.getModel(),
+        metaModel = model.getMetaModel(),
+        itemsModel = new TemplateModel(oDataFieldModel.getData(), metaModel);
+      const oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment");
+      const oCreatedFragment = await Promise.resolve(XMLPreprocessor.process(oFragment, {
+        name: sFragmentName
+      }, {
+        bindingContexts: {
+          dataFieldModel: itemsModel.createBindingContext("/"),
+          metaModel: metaModel.createBindingContext("/"),
+          contextPath: metaModel.createBindingContext(metaModel.getMetaPath(dialogContext.getPath()))
+        },
+        models: {
+          dataFieldModel: itemsModel,
+          metaModel: metaModel,
+          contextPath: metaModel
+        }
+      }));
+      const oDialogContent = await Fragment.load({
+        definition: oCreatedFragment
+      });
+      const oDialog = new Dialog({
+        resizable: true,
+        title: oDefaultValues.massEditTitle,
+        content: [oDialogContent],
+        afterOpen: MassEditHelper.onDialogOpen,
+        beginButton: new Button({
+          text: MassEditHelper.helpers.getExpBindingForApplyButtonTxt(oDefaultValues, oDataFieldModel.getObject("/")),
+          type: "Emphasized",
+          press: async function (oEvent) {
+            var _oController$getView6, _oController$getView7;
+            messageHandling.removeBoundTransitionMessages();
+            messageHandling.removeUnboundTransitionMessages();
+            (_oController$getView6 = oController.getView()) === null || _oController$getView6 === void 0 ? void 0 : (_oController$getView7 = _oController$getView6.getBindingContext("internal")) === null || _oController$getView7 === void 0 ? void 0 : _oController$getView7.setProperty("skipPatchHandlers", true);
+            const oInDialog = oEvent.getSource().getParent();
+            const oModel = oInDialog.getModel("fieldsInfo");
+            const aResults = oModel.getProperty("/results");
+            const oMetaModel = oTable && oTable.getModel().getMetaModel(),
+              sCurrentEntitySetName = oTable.data("metaPath"),
+              oEntitySetContext = oMetaModel.getContext(sCurrentEntitySetName);
+            const aSideEffects = await SideEffectsHelper.generateSideEffectsMapFromMetaModel(oMetaModel);
+            const errorContexts = [];
+            const textPaths = oModel.getProperty("/textPaths");
+            const aPropertyReadableInfo = oModel.getProperty("/readablePropertyData");
+            let groupId;
+            let allSideEffects;
+            const massEditPromises = [];
+            const failedFieldsData = {};
+            const selectedRowsLength = aContexts.length;
+            const deferredTargetsForAQualifiedName = {};
+            const baseSideEffectsMapArray = MassEditHelper.getSideEffectDataForKey(oEntitySetContext, aSideEffects, oController, aResults);
+            //const changePromise: any[] = [];
+            //let bReadOnlyField = false;
+            //const errorContexts: object[] = [];
+
+            aContexts.forEach(function (oSelectedContext, idx) {
+              allSideEffects = [];
+              aResults.forEach(async function (oResult) {
+                if (!failedFieldsData.hasOwnProperty(oResult.keyValue)) {
+                  failedFieldsData[oResult.keyValue] = 0;
+                }
+                //TODO - Add save implementation for Value Help.
+                if (baseSideEffectsMapArray[oResult.keyValue]) {
+                  allSideEffects[oResult.keyValue] = baseSideEffectsMapArray[oResult.keyValue];
+                }
+                if (aPropertyReadableInfo) {
+                  aPropertyReadableInfo.some(function (oPropertyInfo) {
+                    if (oResult.keyValue === oPropertyInfo.property) {
+                      if (oPropertyInfo.type === "Default") {
+                        return oPropertyInfo.value === true;
+                      } else if (oPropertyInfo.type === "Path" && oPropertyInfo.propertyValue && oPropertyInfo.propertyPath) {
+                        return oSelectedContext.getObject(oPropertyInfo.propertyPath) === oPropertyInfo.propertyValue;
+                      }
+                    }
+                  });
+                }
+                groupId = `$auto.${idx}`;
+                const oFieldPromise = oSelectedContext.setProperty(oResult.keyValue, oResult.value, groupId).catch(function (oError) {
+                  errorContexts.push(oSelectedContext.getObject());
+                  Log.error("Mass Edit: Something went wrong in updating entries.", oError);
+                  failedFieldsData[oResult.keyValue] = failedFieldsData[oResult.keyValue] + 1;
+                  return Promise.reject({
+                    isFieldUpdateFailed: true
+                  });
+                });
+                const dataToUpdateFieldAndSideEffects = {
+                  oController,
+                  oFieldPromise,
+                  sideEffectsMap: baseSideEffectsMapArray[oResult.keyValue],
+                  textPaths,
+                  groupId,
+                  key: oResult.keyValue,
+                  oEntitySetContext,
+                  oMetaModel,
+                  oSelectedContext,
+                  deferredTargetsForAQualifiedName
+                };
+                massEditPromises.push(MassEditHelper.handleMassEditFieldUpdateAndRequestSideEffects(dataToUpdateFieldAndSideEffects));
+              });
+            });
+            await Promise.allSettled(massEditPromises).then(async function () {
+              groupId = `$auto.massEditDeferred`;
+              const deferredRequests = [];
+              const sideEffectsDataForAllKeys = Object.values(deferredTargetsForAQualifiedName);
+              const keysWithSideEffects = Object.keys(deferredTargetsForAQualifiedName);
+              sideEffectsDataForAllKeys.forEach((aSideEffect, index) => {
+                const currentKey = keysWithSideEffects[index];
+                if (failedFieldsData[currentKey] !== selectedRowsLength) {
+                  const deferredSideEffectsData = Object.values(aSideEffect);
+                  deferredSideEffectsData.forEach(req => {
+                    const {
+                      aTargets,
+                      oContext,
+                      TriggerAction,
+                      mSideEffect
+                    } = req;
+                    const fnGetDeferredTargets = function () {
+                      return aTargets;
+                    };
+                    const fnGetDeferredTargetsAndActions = function () {
+                      return {
+                        aTargets: fnGetDeferredTargets(),
+                        TriggerAction: TriggerAction
+                      };
+                    };
+                    deferredRequests.push(
+                    // if some deferred is rejected, it will be add to failed queue
+                    oController._sideEffects.requestSideEffects(mSideEffect, oContext, groupId, fnGetDeferredTargetsAndActions));
+                  });
+                }
+              });
+            }).then(function () {
+              MassEditHelper.messageHandlingForMassEdit(oTable, aContexts, oController, oInDialog, aResults, errorContexts);
+            }).catch(e => {
+              MassEditHelper.closeDialog(oDialog);
+              return Promise.reject(e);
+            });
+          }
+        }),
+        endButton: new Button({
+          text: oDefaultValues.cancelButtonText,
+          visible: MassEditHelper.helpers.hasEditableFieldsBinding(oDataFieldModel.getObject("/"), true),
+          press: function (oEvent) {
+            const oInDialog = oEvent.getSource().getParent();
+            MassEditHelper.closeDialog(oInDialog);
+          }
+        })
+      });
+      oDialog.setModel(oDialogDataModel, "fieldsInfo");
+      oDialog.setModel(model);
+      oDialog.setBindingContext(dialogContext);
+      return oDialog;
+    },
+    helpers: {
+      getBindingExpForHasEditableFields: (fields, editable) => {
+        const totalExp = fields.reduce((expression, field) => or(expression, pathInModel("/values/" + field.dataProperty + "/visible", "fieldsInfo")), constant(false));
+        return editable ? totalExp : not(totalExp);
+      },
+      getExpBindingForApplyButtonTxt: (defaultValues, fields) => {
+        const editableExp = MassEditHelper.helpers.getBindingExpForHasEditableFields(fields, true);
+        const totalExp = ifElse(editableExp, constant(defaultValues.applyButtonText), constant(defaultValues.okButtonText));
+        return compileExpression(totalExp);
+      },
+      hasEditableFieldsBinding: (fields, editable) => {
+        return compileExpression(MassEditHelper.helpers.getBindingExpForHasEditableFields(fields, editable));
+      }
+    }
+  };
+  return MassEditHelper;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["MassEditHelper","initLastLevelOfPropertyPath","sPath","aValues","aFinalPath","index","aPaths","split","sFullPath","forEach","sPropertyPath","getUniqueValues","sValue","self","undefined","indexOf","getValueForMultiLevelPath","sDataPropertyPath","oValues","result","aPropertyPaths","getDefaultSelectionPathComboBox","aContexts","length","oSelectedContext","aPropertyValues","oContext","oDataObject","getObject","sMultiLevelPathCondition","hasOwnProperty","push","aUniquePropertyValues","filter","getHiddenValueForContexts","hiddenValue","$Path","some","getInputType","propertyInfo","dataFieldConverted","oDataModelPath","editStyleProperties","inputType","setEditStyleProperties","editStyle","isValidForMassEdit","isMultiValueField","hasValueHelpWithFixedValues","getIsFieldGrp","$Type","Target","value","getTextPath","property","textBinding","displayMode","descriptionPath","path","parameters","props","prepareDataForDialog","oTable","aDataArray","oMetaModel","getModel","getMetaModel","sCurrentEntitySetName","data","aTableFields","getTableFields","oEntityTypeContext","getContext","oEntitySetContext","oDataModelObjectPath","getInvolvedDataModelObjects","oDataFieldModel","JSONModel","oResult","sLabelText","bValueHelpEnabled","sUnitPropertyPath","bValueHelpEnabledForUnit","oTextBinding","oColumnInfo","dataProperty","oPropertyInfo","label","targetObject","targetEntityType","entityProperties","oProperty","name","getTextBinding","oFieldContext","annotationPath","oDataFieldConverted","convertMetaModelContext","oPropertyContext","oInterface","getInterface","Value","enhanceDataModelPath","bHiddenField","isImage","context","getPath","_type","$target","chartProperty","term","isAction","Action","isFieldGrp","hasCurrency","hasUnit","getAssociatedUnitPropertyPath","unitPropertyInfo","getAssociatedUnitProperty","hasValueHelp","hasContextDependentVH","annotations","Common","ValueListRelevantQualifiers","propertyForFieldControl","expBinding","getEditMode","constant","editModeValues","Object","keys","EditMode","editModeIsStatic","includes","editable","Editable","navPropertyWithValueHelp","relativePath","getRelativePaths","isReadOnly","isReadOnlyExpression","CommonUtils","computeDisplayMode","isValueHelpEnabled","isValueHelpEnabledForUnit","unitProperty","isFieldRequired","getRequiredExpression","defaultSelectionPath","defaultSelectionUnitPath","entitySet","display","nullable","isPropertyReadOnly","editMode","hasVH","runtimePath","propertyPathForValueHelp","unitInfo","setData","aColumns","getColumns","columnsData","getParent","getTableDefinition","columns","map","oColumn","sDataProperty","getDataProperty","aRealtedColumnInfo","type","getHeader","getDefaultTextsForDialog","oResourceBundle","iSelectedContexts","bDisplayMode","keepExistingPrefix","leaveBlankValue","clearFieldValue","massEditTitle","getText","toString","applyButtonText","useValueHelpValue","cancelButtonText","noFields","okButtonText","setDefaultValuesToDialog","oDefaultValues","bUOMField","sInputType","bPropertyRequired","sSuffixForKeepExisting","defaultOptions","selectOptionsExist","selectOptions","keepEntry","text","key","falseEntry","textInfo","truthyEntry","unshift","vhdEntry","clearEntry","emptyEntry","getTextArrangementInfo","selectedContext","descriptionValue","fullText","Log","info","textArrangement","valuePath","description","isEditable","any","binding","getBinding","getExternalValue","onContextEditableChange","oDialogDataModel","objectsForVisibility","getProperty","setProperty","updateOnContextChange","mOToUse","values","attachChange","bind","getBoundObject","Any","model","setModel","setBindingContext","getFieldVisiblity","isContextEditable","setRuntimeModelOnDialog","dialogContext","aUnitData","aResults","textPaths","aReadOnlyFieldInfo","oData","unitData","results","readablePropertyData","selectedKey","oInData","oTextInfo","sPropertyKey","sUnitPropertyName","oDistinctValueMap","oDistinctUnitMap","sMultiLevelPathValue","entry","unitEntry","sMultiLevelPropPathValue","bClearFieldOrBlankValueExists","obj","bClearFieldOrBlankUnitValueExists","operands","operand1","operand2","propertyPath","propertyValue","visible","getDialogContext","table","dialog","transCtx","getBindingContext","listBinding","getRowBinding","transientListBinding","bindList","$$updateGroupId","refreshInternal","create","onDialogOpen","event","source","getSource","fieldsInfoModel","closeDialog","oDialog","close","destroy","messageHandlingForMassEdit","oController","oInDialog","errorContexts","DraftStatus","FELibrary","Core","getLibraryResourceBundle","getView","_editFlow","getMessageHandler","showMessages","onBeforeShowMessage","messages","showMessageParameters","fnGetMessageSubtitle","messageHandling","setMessageSubtitle","unboundErrors","message","getTarget","setDraftStatus","Saved","successToast","MessageToast","show","getSelectedContexts","Clear","showMessageBox","showMessageDialog","isOpen","getSideEffectDataForKey","aSideEffects","sOwnerEntityType","baseSideEffectsMapArray","keyValue","sideEffectsArray","FieldHelper","getSideEffectsOnEntityAndProperty","_sideEffects","getSideEffectsMapForFieldGroups","fnGetPathForSourceProperty","sEntityType","sNavigationPath","substr","lastIndexOf","pOwnerEntity","Promise","resolve","requestObject","fnGetEntityTypeOfOwner","baseNavPath","targetEntity","aTargets","ownerEntityType","pOwner","$Partner","ownerNavPath","entityObjOfOwnerPartner","entityTypeOfOwnerPartner","fnGetTargetsForMassEdit","sideEffectsData","TargetProperties","aTargetProperties","TargetEntities","aTargetEntities","aPromises","targetProp","then","resultEntity","all","checkIfEntityExistsAsTargetEntity","sideEffectsMap","sideEffectsOnOtherEntity","entitySetName","pop","sideEffectsWithCurrentEntityAsTarget","targetEntitiesArray","sideEffects","innerObj","handleMassEditFieldUpdateAndRequestSideEffects","mParams","oFieldPromise","groupId","deferredTargetsForAQualifiedName","immediateSideEffectsPromises","oAppComponent","getAppComponent","oSideEffectsService","getSideEffectsService","isSideEffectsWithCurrentEntityAsTarget","allEntityTypesWithQualifier","sideEffectsDataForField","mVisitedSideEffects","entries","entityTypeWithQualifier","getContextForSideEffects","allFailedSideEffects","getRegisteredFailedRequests","aFailedSideEffects","unregisterFailedSideEffectsForAContext","sideEffectsForCurrentContext","concat","aSideEffect","fullyQualifiedName","aImmediateTargets","allTargets","triggerActionName","fnGetImmediateTargetsAndActions","mSideEffect","sideEffectEntityType","targetsArrayForAllProperties","actionName","TriggerAction","aDeferredTargets","target","isStaticAction","TableHelper","_isStaticAction","requestSideEffects","allSettled","createDialog","sFragmentName","metaModel","itemsModel","TemplateModel","getData","oFragment","XMLTemplateProcessor","loadTemplate","oCreatedFragment","XMLPreprocessor","process","bindingContexts","dataFieldModel","createBindingContext","contextPath","getMetaPath","models","oDialogContent","Fragment","load","definition","Dialog","resizable","title","content","afterOpen","beginButton","Button","helpers","getExpBindingForApplyButtonTxt","press","oEvent","removeBoundTransitionMessages","removeUnboundTransitionMessages","oModel","SideEffectsHelper","generateSideEffectsMapFromMetaModel","aPropertyReadableInfo","allSideEffects","massEditPromises","failedFieldsData","selectedRowsLength","idx","catch","oError","error","reject","isFieldUpdateFailed","dataToUpdateFieldAndSideEffects","deferredRequests","sideEffectsDataForAllKeys","keysWithSideEffects","currentKey","deferredSideEffectsData","req","fnGetDeferredTargets","fnGetDeferredTargetsAndActions","e","endButton","hasEditableFieldsBinding","getBindingExpForHasEditableFields","fields","totalExp","reduce","expression","field","or","pathInModel","not","defaultValues","editableExp","ifElse","compileExpression"],"sourceRoot":".","sources":["MassEditHelper.ts"],"sourcesContent":["import Log from \"sap/base/Log\";\nimport CommonUtils from \"sap/fe/core/CommonUtils\";\nimport type {\n\tFieldSideEffectDictionary,\n\tMassEditFieldSideEffectDictionary,\n\tMassEditFieldSideEffectPropertyType\n} from \"sap/fe/core/controllerextensions/SideEffects\";\nimport type { BindingToolkitExpression, CompiledBindingToolkitExpression } from \"sap/fe/core/helpers/BindingToolkit\";\nimport { compileExpression, constant, ifElse, not, or, pathInModel } from \"sap/fe/core/helpers/BindingToolkit\";\nimport FELibrary from \"sap/fe/core/library\";\nimport type PageController from \"sap/fe/core/PageController\";\nimport type { ODataSideEffectsType, SideEffectsTargetEntityType, SideEffectsType } from \"sap/fe/core/services/SideEffectsServiceFactory\";\nimport TemplateModel from \"sap/fe/core/TemplateModel\";\nimport type { DataModelObjectPath } from \"sap/fe/core/templating/DataModelPathHelper\";\nimport { enhanceDataModelPath, getRelativePaths } from \"sap/fe/core/templating/DataModelPathHelper\";\nimport {\n\tgetAssociatedUnitProperty,\n\tgetAssociatedUnitPropertyPath,\n\thasCurrency,\n\thasUnit,\n\thasValueHelp,\n\thasValueHelpWithFixedValues\n} from \"sap/fe/core/templating/PropertyHelper\";\nimport FieldHelper from \"sap/fe/macros/field/FieldHelper\";\nimport { getTextBinding, setEditStyleProperties } from \"sap/fe/macros/field/FieldTemplating\";\nimport type { FieldProperties } from \"sap/fe/macros/internal/InternalField\";\nimport TableHelper from \"sap/fe/macros/table/TableHelper\";\nimport Button from \"sap/m/Button\";\nimport Dialog from \"sap/m/Dialog\";\nimport MessageToast from \"sap/m/MessageToast\";\nimport Core from \"sap/ui/core/Core\";\nimport Fragment from \"sap/ui/core/Fragment\";\nimport XMLPreprocessor from \"sap/ui/core/util/XMLPreprocessor\";\nimport XMLTemplateProcessor from \"sap/ui/core/XMLTemplateProcessor\";\nimport EditMode from \"sap/ui/mdc/enum/EditMode\";\nimport type Table from \"sap/ui/mdc/Table\";\nimport JSONModel from \"sap/ui/model/json/JSONModel\";\nimport type Context from \"sap/ui/model/odata/v4/Context\";\nimport type ODataListBinding from \"sap/ui/model/odata/v4/ODataListBinding\";\nimport type ODataMetaModel from \"sap/ui/model/odata/v4/ODataMetaModel\";\nimport messageHandling from \"../controllerextensions/messageHandler/messageHandling\";\nimport type { AnyType } from \"../controls/Any\";\nimport Any from \"../controls/Any\";\nimport { convertMetaModelContext, getInvolvedDataModelObjects } from \"../converters/MetaModelConverter\";\nimport { isReadOnlyExpression } from \"../templating/FieldControlHelper\";\nimport { getEditMode, getRequiredExpression, isMultiValueField } from \"../templating/UIFormatters\";\nimport type { InternalModelContext } from \"./ModelHelper\";\nimport SideEffectsHelper from \"./SideEffectsHelper\";\n\n/* This class contains helpers to be used for mass edit functionality */\ntype TextArrangementInfo = {\n\ttextArrangement: string;\n\tvaluePath: string;\n\tdescriptionPath?: string;\n\tvalue: string;\n\tdescription: string;\n\tfullText: string;\n};\n\ntype BindingInfo = {\n\tpath?: string;\n\tmodel?: string | object;\n\tparameters?: Array<BindingInfo>;\n};\n\nexport type DataToUpdateFieldAndSideEffectsType = {\n\toController: PageController;\n\toFieldPromise: Promise<any>;\n\tsideEffectsMap: MassEditFieldSideEffectDictionary | FieldSideEffectDictionary;\n\ttextPaths: any;\n\tgroupId: string;\n\tkey: string;\n\toEntitySetContext: Context;\n\toMetaModel: any;\n\toSelectedContext: any;\n\tdeferredTargetsForAQualifiedName: any;\n};\n\nconst MassEditHelper = {\n\t/**\n\t * Initializes the value at final or deepest level path with a blank array.\n\t * Return an empty array pointing to the final or deepest level path.\n\t *\n\t * @param sPath Property path\n\t * @param aValues Array instance where the default data needs to be added\n\t * @returns The final path\n\t */\n\tinitLastLevelOfPropertyPath: function (sPath: string, aValues: any /*, transCtx: Context */) {\n\t\tlet aFinalPath: any;\n\t\tlet index = 0;\n\t\tconst aPaths = sPath.split(\"/\");\n\t\tlet sFullPath = \"\";\n\t\taPaths.forEach(function (sPropertyPath: string) {\n\t\t\tif (!aValues[sPropertyPath] && index === 0) {\n\t\t\t\taValues[sPropertyPath] = {};\n\t\t\t\taFinalPath = aValues[sPropertyPath];\n\t\t\t\tsFullPath = sFullPath + sPropertyPath;\n\t\t\t\tindex++;\n\t\t\t} else if (!aFinalPath[sPropertyPath]) {\n\t\t\t\tsFullPath = `${sFullPath}/${sPropertyPath}`;\n\t\t\t\tif (sFullPath !== sPath) {\n\t\t\t\t\taFinalPath[sPropertyPath] = {};\n\t\t\t\t\taFinalPath = aFinalPath[sPropertyPath];\n\t\t\t\t} else {\n\t\t\t\t\taFinalPath[sPropertyPath] = [];\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\treturn aFinalPath;\n\t},\n\n\t/**\n\t * Method to get unique values for given array values.\n\t *\n\t * @param sValue Property value\n\t * @param index Index of the property value\n\t * @param self Instance of the array\n\t * @returns The unique value\n\t */\n\tgetUniqueValues: function (sValue: string, index: number, self: any[]) {\n\t\treturn sValue != undefined && sValue != null ? self.indexOf(sValue) === index : undefined;\n\t},\n\n\t/**\n\t * Gets the property value for a multi-level path (for example: _Materials/Material_Details gets the value of Material_Details under _Materials Object).\n\t * Returns the propertyValue, which can be of any type (string, number, etc..).\n\t *\n\t * @param sDataPropertyPath Property path\n\t * @param oValues Object of property values\n\t * @returns The property value\n\t */\n\tgetValueForMultiLevelPath: function (sDataPropertyPath: string, oValues: any) {\n\t\tlet result: any;\n\t\tif (sDataPropertyPath && sDataPropertyPath.indexOf(\"/\") > 0) {\n\t\t\tconst aPropertyPaths = sDataPropertyPath.split(\"/\");\n\t\t\taPropertyPaths.forEach(function (sPath: string) {\n\t\t\t\tresult = oValues && oValues[sPath] ? oValues[sPath] : result && result[sPath];\n\t\t\t});\n\t\t}\n\t\treturn result;\n\t},\n\n\t/**\n\t * Gets the key path for the key of a combo box that must be selected initially when the dialog opens:\n\t * => If propertyValue for all selected contexts is different, then < Keep Existing Values > is preselected.\n\t * => If propertyValue for all selected contexts is the same, then the propertyValue is preselected.\n\t * => If propertyValue for all selected contexts is empty, then < Leave Blank > is preselected.\n\t *\n\t *\n\t * @param aContexts Contexts for mass edit\n\t * @param sDataPropertyPath Data property path\n\t * @returns The key path\n\t */\n\tgetDefaultSelectionPathComboBox: function (aContexts: any[], sDataPropertyPath: string) {\n\t\tlet result: string | undefined;\n\t\tif (sDataPropertyPath && aContexts.length > 0) {\n\t\t\tconst oSelectedContext = aContexts,\n\t\t\t\taPropertyValues: any[] = [];\n\t\t\toSelectedContext.forEach(function (oContext: any) {\n\t\t\t\tconst oDataObject = oContext.getObject();\n\t\t\t\tconst sMultiLevelPathCondition =\n\t\t\t\t\tsDataPropertyPath.indexOf(\"/\") > -1 && oDataObject.hasOwnProperty(sDataPropertyPath.split(\"/\")[0]);\n\t\t\t\tif (oContext && (oDataObject.hasOwnProperty(sDataPropertyPath) || sMultiLevelPathCondition)) {\n\t\t\t\t\taPropertyValues.push(oContext.getObject(sDataPropertyPath));\n\t\t\t\t}\n\t\t\t});\n\t\t\tconst aUniquePropertyValues = aPropertyValues.filter(MassEditHelper.getUniqueValues);\n\t\t\tif (aUniquePropertyValues.length > 1) {\n\t\t\t\tresult = `Default/${sDataPropertyPath}`;\n\t\t\t} else if (aUniquePropertyValues.length === 0) {\n\t\t\t\tresult = `Empty/${sDataPropertyPath}`;\n\t\t\t} else if (aUniquePropertyValues.length === 1) {\n\t\t\t\tresult = `${sDataPropertyPath}/${aUniquePropertyValues[0]}`;\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t},\n\n\t/**\n\t * Checks hidden annotation value [both static and path based] for table's selected context.\n\t *\n\t * @param hiddenValue Hidden annotation value / path for field\n\t * @param aContexts Contexts for mass edit\n\t * @returns The hidden annotation value\n\t */\n\tgetHiddenValueForContexts: function (hiddenValue: any, aContexts: any[]) {\n\t\tif (hiddenValue && hiddenValue.$Path) {\n\t\t\treturn !aContexts.some(function (oSelectedContext: any) {\n\t\t\t\treturn oSelectedContext.getObject(hiddenValue.$Path) === false;\n\t\t\t});\n\t\t}\n\t\treturn hiddenValue;\n\t},\n\n\tgetInputType: function (propertyInfo: any, dataFieldConverted: any, oDataModelPath: DataModelObjectPath): string {\n\t\tconst editStyleProperties = {} as FieldProperties;\n\t\tlet inputType!: string;\n\t\tif (propertyInfo) {\n\t\t\tsetEditStyleProperties(editStyleProperties, dataFieldConverted, oDataModelPath, true);\n\t\t\tinputType = editStyleProperties?.editStyle || \"\";\n\t\t}\n\t\tconst isValidForMassEdit =\n\t\t\tinputType &&\n\t\t\t[\"DatePicker\", \"TimePicker\", \"DateTimePicker\", \"RatingIndicator\"].indexOf(inputType) === -1 &&\n\t\t\t!isMultiValueField(oDataModelPath) &&\n\t\t\t!hasValueHelpWithFixedValues(propertyInfo);\n\n\t\treturn (isValidForMassEdit || \"\") && inputType;\n\t},\n\n\tgetIsFieldGrp: function (dataFieldConverted: any): boolean {\n\t\treturn (\n\t\t\tdataFieldConverted &&\n\t\t\tdataFieldConverted.$Type === \"com.sap.vocabularies.UI.v1.DataFieldForAnnotation\" &&\n\t\t\tdataFieldConverted.Target &&\n\t\t\tdataFieldConverted.Target.value &&\n\t\t\tdataFieldConverted.Target.value.indexOf(\"FieldGroup\") > -1\n\t\t);\n\t},\n\n\t/**\n\t * Get text path for the mass edit field.\n\t *\n\t * @param property Property path\n\t * @param textBinding Text Binding Info\n\t * @param displayMode Display mode\n\t * @returns Text Property Path if it exists\n\t */\n\tgetTextPath: function (property: string, textBinding: any, displayMode: string): string | undefined {\n\t\tlet descriptionPath;\n\t\tif (textBinding && (textBinding.path || (textBinding.parameters && textBinding.parameters.length)) && property) {\n\t\t\tif (textBinding.path && displayMode === \"Description\") {\n\t\t\t\tdescriptionPath = textBinding.path;\n\t\t\t} else if (textBinding.parameters) {\n\t\t\t\ttextBinding.parameters.forEach(function (props: BindingInfo) {\n\t\t\t\t\tif (props.path && props.path !== property) {\n\t\t\t\t\t\tdescriptionPath = props.path;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\treturn descriptionPath;\n\t},\n\n\t/**\n\t * Initializes a JSON Model for properties of dialog fields [label, visiblity, dataproperty, etc.].\n\t *\n\t * @param oTable Instance of Table\n\t * @param aContexts Contexts for mass edit\n\t * @param aDataArray Array containing data related to the dialog used by both the static and the runtime model\n\t * @returns The model\n\t */\n\tprepareDataForDialog: function (oTable: Table, aContexts: any[], aDataArray: any[]) {\n\t\tconst oMetaModel = oTable && (oTable.getModel().getMetaModel() as any),\n\t\t\tsCurrentEntitySetName = oTable.data(\"metaPath\"),\n\t\t\taTableFields = MassEditHelper.getTableFields(oTable),\n\t\t\toEntityTypeContext = oMetaModel.getContext(`${sCurrentEntitySetName}/@`),\n\t\t\toEntitySetContext = oMetaModel.getContext(sCurrentEntitySetName),\n\t\t\toDataModelObjectPath = getInvolvedDataModelObjects(oEntityTypeContext);\n\n\t\tconst oDataFieldModel = new JSONModel();\n\t\tlet oResult;\n\t\tlet sLabelText;\n\t\tlet bValueHelpEnabled;\n\t\tlet sUnitPropertyPath;\n\t\tlet bValueHelpEnabledForUnit;\n\t\tlet oTextBinding;\n\n\t\taTableFields.forEach(function (oColumnInfo: any) {\n\t\t\tconst sDataPropertyPath = oColumnInfo.dataProperty;\n\t\t\tif (sDataPropertyPath) {\n\t\t\t\tlet oPropertyInfo = sDataPropertyPath && oMetaModel.getObject(`${sCurrentEntitySetName}/${sDataPropertyPath}@`);\n\t\t\t\tsLabelText =\n\t\t\t\t\toColumnInfo.label || (oPropertyInfo && oPropertyInfo[\"@com.sap.vocabularies.Common.v1.Label\"]) || sDataPropertyPath;\n\n\t\t\t\tif (oDataModelObjectPath) {\n\t\t\t\t\toDataModelObjectPath.targetObject = oDataModelObjectPath.targetEntityType.entityProperties.filter(function (\n\t\t\t\t\t\toProperty: any\n\t\t\t\t\t) {\n\t\t\t\t\t\treturn oProperty.name === sDataPropertyPath;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\toDataModelObjectPath.targetObject = oDataModelObjectPath.targetObject[0] || {};\n\t\t\t\toTextBinding = getTextBinding(oDataModelObjectPath, {}, true) || {};\n\t\t\t\tconst oFieldContext = oMetaModel.getContext(oColumnInfo.annotationPath),\n\t\t\t\t\toDataFieldConverted = convertMetaModelContext(oFieldContext),\n\t\t\t\t\toPropertyContext = oMetaModel.getContext(`${sCurrentEntitySetName}/${sDataPropertyPath}@`),\n\t\t\t\t\toInterface = oPropertyContext && oPropertyContext.getInterface();\n\n\t\t\t\tlet oDataModelPath = getInvolvedDataModelObjects(oFieldContext, oEntitySetContext);\n\t\t\t\tif (oDataFieldConverted?.Value?.path?.length > 0) {\n\t\t\t\t\toDataModelPath = enhanceDataModelPath(oDataModelPath, sDataPropertyPath);\n\t\t\t\t}\n\t\t\t\tconst bHiddenField =\n\t\t\t\t\tMassEditHelper.getHiddenValueForContexts(\n\t\t\t\t\t\toFieldContext && oFieldContext.getObject()[\"@com.sap.vocabularies.UI.v1.Hidden\"],\n\t\t\t\t\t\taContexts\n\t\t\t\t\t) || false;\n\t\t\t\tconst isImage = oPropertyInfo && oPropertyInfo[\"@com.sap.vocabularies.UI.v1.IsImageURL\"];\n\n\t\t\t\toInterface.context = {\n\t\t\t\t\tgetModel: function () {\n\t\t\t\t\t\treturn oInterface.getModel();\n\t\t\t\t\t},\n\t\t\t\t\tgetPath: function () {\n\t\t\t\t\t\treturn `${sCurrentEntitySetName}/${sDataPropertyPath}`;\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t\toPropertyInfo =\n\t\t\t\t\toDataFieldConverted._type === \"Property\"\n\t\t\t\t\t\t? oDataFieldConverted\n\t\t\t\t\t\t: (oDataFieldConverted && oDataFieldConverted.Value && oDataFieldConverted.Value.$target) ||\n\t\t\t\t\t\t  (oDataFieldConverted && oDataFieldConverted.Target && oDataFieldConverted.Target.$target);\n\t\t\t\t// Datafield is not included in the FieldControl calculation, needs to be implemented\n\n\t\t\t\tconst chartProperty = oPropertyInfo && oPropertyInfo.term && oPropertyInfo.term === \"com.sap.vocabularies.UI.v1.Chart\";\n\t\t\t\tconst isAction = !!oDataFieldConverted.Action;\n\t\t\t\tconst isFieldGrp = MassEditHelper.getIsFieldGrp(oDataFieldConverted);\n\t\t\t\tif (isImage || bHiddenField || chartProperty || isAction || isFieldGrp) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// ValueHelp properties\n\t\t\t\tsUnitPropertyPath =\n\t\t\t\t\t((hasCurrency(oPropertyInfo) || hasUnit(oPropertyInfo)) && getAssociatedUnitPropertyPath(oPropertyInfo)) || \"\";\n\t\t\t\tconst unitPropertyInfo = sUnitPropertyPath && getAssociatedUnitProperty(oPropertyInfo);\n\t\t\t\tbValueHelpEnabled = hasValueHelp(oPropertyInfo);\n\t\t\t\tbValueHelpEnabledForUnit = unitPropertyInfo && hasValueHelp(unitPropertyInfo);\n\n\t\t\t\tconst hasContextDependentVH =\n\t\t\t\t\t(bValueHelpEnabled || bValueHelpEnabledForUnit) &&\n\t\t\t\t\t(oPropertyInfo?.annotations?.Common?.ValueListRelevantQualifiers ||\n\t\t\t\t\t\t(unitPropertyInfo && unitPropertyInfo?.annotations?.Common?.ValueListRelevantQualifiers));\n\t\t\t\tif (hasContextDependentVH) {\n\t\t\t\t\t// context dependent VH is not supported for Mass Edit.\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// EditMode and InputType\n\t\t\t\tconst propertyForFieldControl = oPropertyInfo && oPropertyInfo.Value ? oPropertyInfo.Value : oPropertyInfo;\n\t\t\t\tconst expBinding = getEditMode(propertyForFieldControl, oDataModelPath, false, false, oDataFieldConverted, constant(true));\n\t\t\t\tconst editModeValues = Object.keys(EditMode);\n\t\t\t\tconst editModeIsStatic = !!expBinding && editModeValues.includes(expBinding as EditMode);\n\t\t\t\tconst editable = !!expBinding && ((editModeIsStatic && expBinding === EditMode.Editable) || !editModeIsStatic);\n\t\t\t\tconst navPropertyWithValueHelp = sDataPropertyPath.includes(\"/\") && bValueHelpEnabled;\n\t\t\t\tif (!editable || navPropertyWithValueHelp) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tconst inputType = MassEditHelper.getInputType(oPropertyInfo, oDataFieldConverted, oDataModelPath);\n\n\t\t\t\tif (inputType) {\n\t\t\t\t\tconst relativePath = getRelativePaths(oDataModelPath);\n\t\t\t\t\tconst isReadOnly = isReadOnlyExpression(oPropertyInfo, relativePath);\n\t\t\t\t\tconst displayMode = CommonUtils.computeDisplayMode(oPropertyContext.getObject());\n\t\t\t\t\tconst isValueHelpEnabled = bValueHelpEnabled ? bValueHelpEnabled : false;\n\t\t\t\t\tconst isValueHelpEnabledForUnit =\n\t\t\t\t\t\tbValueHelpEnabledForUnit && !sUnitPropertyPath.includes(\"/\") ? bValueHelpEnabledForUnit : false;\n\t\t\t\t\tconst unitProperty = sUnitPropertyPath && !sDataPropertyPath.includes(\"/\") ? sUnitPropertyPath : false;\n\n\t\t\t\t\toResult = {\n\t\t\t\t\t\tlabel: sLabelText,\n\t\t\t\t\t\tdataProperty: sDataPropertyPath,\n\t\t\t\t\t\tisValueHelpEnabled: bValueHelpEnabled ? bValueHelpEnabled : false,\n\t\t\t\t\t\tunitProperty,\n\t\t\t\t\t\tisFieldRequired: getRequiredExpression(oPropertyInfo, oDataFieldConverted, true, false, {}, oDataModelPath),\n\t\t\t\t\t\tdefaultSelectionPath: sDataPropertyPath\n\t\t\t\t\t\t\t? MassEditHelper.getDefaultSelectionPathComboBox(aContexts, sDataPropertyPath)\n\t\t\t\t\t\t\t: false,\n\t\t\t\t\t\tdefaultSelectionUnitPath: sUnitPropertyPath\n\t\t\t\t\t\t\t? MassEditHelper.getDefaultSelectionPathComboBox(aContexts, sUnitPropertyPath)\n\t\t\t\t\t\t\t: false,\n\t\t\t\t\t\tentitySet: sCurrentEntitySetName,\n\t\t\t\t\t\tdisplay: displayMode,\n\t\t\t\t\t\tdescriptionPath: MassEditHelper.getTextPath(sDataPropertyPath, oTextBinding, displayMode),\n\t\t\t\t\t\tnullable: oPropertyInfo.nullable !== undefined ? oPropertyInfo.nullable : true,\n\t\t\t\t\t\tisPropertyReadOnly: isReadOnly !== undefined ? isReadOnly : false,\n\t\t\t\t\t\tinputType: inputType,\n\t\t\t\t\t\teditMode: editable ? expBinding : undefined,\n\t\t\t\t\t\tpropertyInfo: {\n\t\t\t\t\t\t\thasVH: isValueHelpEnabled,\n\t\t\t\t\t\t\truntimePath: \"fieldsInfo>/values/\",\n\t\t\t\t\t\t\trelativePath: sDataPropertyPath,\n\t\t\t\t\t\t\tpropertyPathForValueHelp: `${sCurrentEntitySetName}/${sDataPropertyPath}`\n\t\t\t\t\t\t},\n\t\t\t\t\t\tunitInfo: unitProperty && {\n\t\t\t\t\t\t\thasVH: isValueHelpEnabledForUnit,\n\t\t\t\t\t\t\truntimePath: \"fieldsInfo>/unitData/\",\n\t\t\t\t\t\t\trelativePath: unitProperty,\n\t\t\t\t\t\t\tpropertyPathForValueHelp: `${sCurrentEntitySetName}/${unitProperty}`\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\taDataArray.push(oResult);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\toDataFieldModel.setData(aDataArray);\n\t\treturn oDataFieldModel;\n\t},\n\n\tgetTableFields: function (oTable: any) {\n\t\tconst aColumns = (oTable && oTable.getColumns()) || [];\n\t\tconst columnsData = oTable && oTable.getParent().getTableDefinition().columns;\n\t\treturn aColumns.map(function (oColumn: any) {\n\t\t\tconst sDataProperty = oColumn && oColumn.getDataProperty(),\n\t\t\t\taRealtedColumnInfo =\n\t\t\t\t\tcolumnsData &&\n\t\t\t\t\tcolumnsData.filter(function (oColumnInfo: any) {\n\t\t\t\t\t\treturn oColumnInfo.name === sDataProperty && oColumnInfo.type === \"Annotation\";\n\t\t\t\t\t});\n\t\t\treturn {\n\t\t\t\tdataProperty: sDataProperty,\n\t\t\t\tlabel: oColumn.getHeader(),\n\t\t\t\tannotationPath: aRealtedColumnInfo && aRealtedColumnInfo[0] && aRealtedColumnInfo[0].annotationPath\n\t\t\t};\n\t\t});\n\t},\n\n\tgetDefaultTextsForDialog: function (oResourceBundle: any, iSelectedContexts: any, oTable: any) {\n\t\t// The confirm button text is \"Save\" for table in Display mode and \"Apply\" for table in edit mode. This can be later exposed if needed.\n\t\tconst bDisplayMode = oTable.data(\"displayModePropertyBinding\") === \"true\";\n\n\t\treturn {\n\t\t\tkeepExistingPrefix: \"< Keep\",\n\t\t\tleaveBlankValue: \"< Leave Blank >\",\n\t\t\tclearFieldValue: \"< Clear Values >\",\n\t\t\tmassEditTitle: oResourceBundle.getText(\"C_MASS_EDIT_DIALOG_TITLE\", iSelectedContexts.toString()),\n\t\t\tapplyButtonText: bDisplayMode\n\t\t\t\t? oResourceBundle.getText(\"C_MASS_EDIT_SAVE_BUTTON_TEXT\")\n\t\t\t\t: oResourceBundle.getText(\"C_MASS_EDIT_APPLY_BUTTON_TEXT\"),\n\t\t\tuseValueHelpValue: \"< Use Value Help >\",\n\t\t\tcancelButtonText: oResourceBundle.getText(\"C_COMMON_OBJECT_PAGE_CANCEL\"),\n\t\t\tnoFields: oResourceBundle.getText(\"C_MASS_EDIT_NO_EDITABLE_FIELDS\"),\n\t\t\tokButtonText: oResourceBundle.getText(\"C_COMMON_DIALOG_OK\")\n\t\t};\n\t},\n\n\t/**\n\t * Adds a suffix to the 'keep existing' property of the comboBox.\n\t *\n\t * @param sInputType InputType of the field\n\t * @returns The modified string\n\t */\n\t// getSuffixForKeepExisiting: function (sInputType: string) {\n\t// \tlet sResult = \"Values\";\n\n\t// \tswitch (sInputType) {\n\t// \t\t//TODO - Add for other control types as well (Radio Button, Email, Input, MDC Fields, Image etc.)\n\t// \t\tcase \"DatePicker\":\n\t// \t\t\tsResult = \"Dates\";\n\t// \t\t\tbreak;\n\t// \t\tcase \"CheckBox\":\n\t// \t\t\tsResult = \"Settings\";\n\t// \t\t\tbreak;\n\t// \t\tdefault:\n\t// \t\t\tsResult = \"Values\";\n\t// \t}\n\t// \treturn sResult;\n\t// },\n\n\t/**\n\t * Adds default values to the model [Keep Existing Values, Leave Blank].\n\t *\n\t * @param aValues Array instance where the default data needs to be added\n\t * @param oDefaultValues Default values from Application Manifest\n\t * @param oPropertyInfo Property information\n\t * @param bUOMField\n\t */\n\tsetDefaultValuesToDialog: function (aValues: any, oDefaultValues: any, oPropertyInfo: any, bUOMField?: boolean) {\n\t\tconst sPropertyPath = bUOMField ? oPropertyInfo.unitProperty : oPropertyInfo.dataProperty,\n\t\t\tsInputType = oPropertyInfo.inputType,\n\t\t\tbPropertyRequired = oPropertyInfo.isFieldRequired;\n\t\t// const sSuffixForKeepExisting = MassEditHelper.getSuffixForKeepExisiting(sInputType);\n\t\tconst sSuffixForKeepExisting = \"Values\";\n\t\taValues.defaultOptions = aValues.defaultOptions || [];\n\t\tconst selectOptionsExist = aValues.selectOptions && aValues.selectOptions.length > 0;\n\t\tconst keepEntry = {\n\t\t\ttext: `${oDefaultValues.keepExistingPrefix} ${sSuffixForKeepExisting} >`,\n\t\t\tkey: `Default/${sPropertyPath}`\n\t\t};\n\n\t\tif (sInputType === \"CheckBox\") {\n\t\t\tconst falseEntry = { text: \"No\", key: `${sPropertyPath}/false`, textInfo: { value: false } };\n\t\t\tconst truthyEntry = { text: \"Yes\", key: `${sPropertyPath}/true`, textInfo: { value: true } };\n\t\t\taValues.unshift(falseEntry);\n\t\t\taValues.defaultOptions.unshift(falseEntry);\n\t\t\taValues.unshift(truthyEntry);\n\t\t\taValues.defaultOptions.unshift(truthyEntry);\n\t\t\taValues.unshift(keepEntry);\n\t\t\taValues.defaultOptions.unshift(keepEntry);\n\t\t} else {\n\t\t\tif (oPropertyInfo?.propertyInfo?.hasVH || (oPropertyInfo?.unitInfo?.hasVH && bUOMField)) {\n\t\t\t\tconst vhdEntry = { text: oDefaultValues.useValueHelpValue, key: `UseValueHelpValue/${sPropertyPath}` };\n\t\t\t\taValues.unshift(vhdEntry);\n\t\t\t\taValues.defaultOptions.unshift(vhdEntry);\n\t\t\t}\n\t\t\tif (selectOptionsExist) {\n\t\t\t\tif (bPropertyRequired !== \"true\" && !bUOMField) {\n\t\t\t\t\tconst clearEntry = { text: oDefaultValues.clearFieldValue, key: `ClearFieldValue/${sPropertyPath}` };\n\t\t\t\t\taValues.unshift(clearEntry);\n\t\t\t\t\taValues.defaultOptions.unshift(clearEntry);\n\t\t\t\t}\n\t\t\t\taValues.unshift(keepEntry);\n\t\t\t\taValues.defaultOptions.unshift(keepEntry);\n\t\t\t} else {\n\t\t\t\tconst emptyEntry = { text: oDefaultValues.leaveBlankValue, key: `Default/${sPropertyPath}` };\n\t\t\t\taValues.unshift(emptyEntry);\n\t\t\t\taValues.defaultOptions.unshift(emptyEntry);\n\t\t\t}\n\t\t}\n\t},\n\n\t/**\n\t * Get text arrangement info for a context property.\n\t *\n\t * @param property Property Path\n\t * @param descriptionPath Path to text association of the property\n\t * @param displayMode Display mode of the property and text association\n\t * @param selectedContext Context to find the full text\n\t * @returns The text arrangement\n\t */\n\tgetTextArrangementInfo: function (\n\t\tproperty: string,\n\t\tdescriptionPath: string,\n\t\tdisplayMode: string,\n\t\tselectedContext: Context\n\t): TextArrangementInfo {\n\t\tlet value = selectedContext.getObject(property),\n\t\t\tdescriptionValue,\n\t\t\tfullText;\n\t\tif (descriptionPath && property) {\n\t\t\tswitch (displayMode) {\n\t\t\t\tcase \"Description\":\n\t\t\t\t\tdescriptionValue = selectedContext.getObject(descriptionPath) || \"\";\n\t\t\t\t\tfullText = descriptionValue;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"Value\":\n\t\t\t\t\tvalue = selectedContext.getObject(property) || \"\";\n\t\t\t\t\tfullText = value;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"ValueDescription\":\n\t\t\t\t\tvalue = selectedContext.getObject(property) || \"\";\n\t\t\t\t\tdescriptionValue = selectedContext.getObject(descriptionPath) || \"\";\n\t\t\t\t\tfullText = descriptionValue ? `${value} (${descriptionValue})` : value;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"DescriptionValue\":\n\t\t\t\t\tvalue = selectedContext.getObject(property) || \"\";\n\t\t\t\t\tdescriptionValue = selectedContext.getObject(descriptionPath) || \"\";\n\t\t\t\t\tfullText = descriptionValue ? `${descriptionValue} (${value})` : value;\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tLog.info(`Display Property not applicable: ${property}`);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn {\n\t\t\ttextArrangement: displayMode,\n\t\t\tvaluePath: property,\n\t\t\tdescriptionPath: descriptionPath,\n\t\t\tvalue: value,\n\t\t\tdescription: descriptionValue,\n\t\t\tfullText: fullText\n\t\t};\n\t},\n\n\t/**\n\t * Return the visibility valuue for the ManagedObject Any.\n\t *\n\t * @param any The ManagedObject Any to be used to calculate the visible value of the binding.\n\t * @returns Returns true if the mass edit field is editable.\n\t */\n\tisEditable: function (any: AnyType): boolean {\n\t\tconst binding = any.getBinding(\"any\");\n\t\tconst value = (binding as any).getExternalValue();\n\t\treturn value === EditMode.Editable;\n\t},\n\n\t/**\n\t * Calculate and update the visibility of mass edit field on change of the ManagedObject Any binding.\n\t *\n\t * @param oDialogDataModel Model to be used runtime.\n\t * @param dataProperty Field name.\n\t */\n\tonContextEditableChange: function (oDialogDataModel: JSONModel, dataProperty: string): void {\n\t\tconst objectsForVisibility = oDialogDataModel.getProperty(`/values/${dataProperty}/objectsForVisibility`) || [];\n\t\tconst editable = objectsForVisibility.some(MassEditHelper.isEditable);\n\n\t\tif (editable) {\n\t\t\toDialogDataModel.setProperty(`/values/${dataProperty}/visible`, editable);\n\t\t}\n\t},\n\n\t/**\n\t * Update Managed Object Any for visibility of the mass edit fields.\n\t *\n\t * @param mOToUse The ManagedObject Any to be used to calculate the visible value of the binding.\n\t * @param oDialogDataModel Model to be used runtime.\n\t * @param dataProperty Field name.\n\t * @param values Values of the field.\n\t */\n\tupdateOnContextChange: function (mOToUse: AnyType, oDialogDataModel: JSONModel, dataProperty: string, values: any) {\n\t\tconst binding = mOToUse.getBinding(\"any\");\n\n\t\tvalues.objectsForVisibility = values.objectsForVisibility || [];\n\t\tvalues.objectsForVisibility.push(mOToUse);\n\n\t\tbinding?.attachChange(MassEditHelper.onContextEditableChange.bind(null, oDialogDataModel, dataProperty));\n\t},\n\n\t/**\n\t * Get bound object to calculate the visibility of contexts.\n\t *\n\t * @param expBinding Binding String object.\n\t * @param context Context the binding value.\n\t * @returns The ManagedObject Any to be used to calculate the visible value of the binding.\n\t */\n\tgetBoundObject: function (expBinding: CompiledBindingToolkitExpression, context: Context): AnyType {\n\t\tconst mOToUse = new Any({ any: expBinding });\n\t\tconst model = context.getModel();\n\t\tmOToUse.setModel(model);\n\t\tmOToUse.setBindingContext(context);\n\n\t\treturn mOToUse;\n\t},\n\n\t/**\n\t * Get the visibility of the field.\n\t *\n\t * @param expBinding Binding String object.\n\t * @param oDialogDataModel Model to be used runtime.\n\t * @param dataProperty Field name.\n\t * @param values Values of the field.\n\t * @param context Context the binding value.\n\t * @returns Returns true if the mass edit field is editable.\n\t */\n\tgetFieldVisiblity: function (\n\t\texpBinding: CompiledBindingToolkitExpression,\n\t\toDialogDataModel: JSONModel,\n\t\tdataProperty: string,\n\t\tvalues: any,\n\t\tcontext: Context\n\t): boolean {\n\t\tconst mOToUse = MassEditHelper.getBoundObject(expBinding, context);\n\t\tconst isContextEditable = MassEditHelper.isEditable(mOToUse);\n\n\t\tif (!isContextEditable) {\n\t\t\tMassEditHelper.updateOnContextChange(mOToUse, oDialogDataModel, dataProperty, values);\n\t\t}\n\t\treturn isContextEditable;\n\t},\n\n\t/**\n\t * Initializes a runtime model:\n\t * => The model consists of values shown in the comboBox of the dialog (Leave Blank, Keep Existing Values, or any property value for the selected context, etc.)\n\t * => The model will capture runtime changes in the results property (the value entered in the comboBox).\n\t *\n\t * @param aContexts Contexts for mass edit\n\t * @param aDataArray Array containing data related to the dialog used by both the static and the runtime model\n\t * @param oDefaultValues Default values from i18n\n\t * @param dialogContext Transient context for mass edit dialog.\n\t * @returns The runtime model\n\t */\n\tsetRuntimeModelOnDialog: function (aContexts: any[], aDataArray: any[], oDefaultValues: any, dialogContext: Context) {\n\t\tconst aValues: any[] = [];\n\t\tconst aUnitData: any[] = [];\n\t\tconst aResults: any[] = [];\n\t\tconst textPaths: any[] = [];\n\t\tconst aReadOnlyFieldInfo: any[] = [];\n\n\t\tconst oData = {\n\t\t\tvalues: aValues,\n\t\t\tunitData: aUnitData,\n\t\t\tresults: aResults,\n\t\t\treadablePropertyData: aReadOnlyFieldInfo,\n\t\t\tselectedKey: undefined,\n\t\t\ttextPaths: textPaths,\n\t\t\tnoFields: oDefaultValues.noFields\n\t\t};\n\t\tconst oDialogDataModel = new JSONModel(oData);\n\t\taDataArray.forEach(function (oInData: any) {\n\t\t\tlet oTextInfo;\n\t\t\tlet sPropertyKey;\n\t\t\tlet sUnitPropertyName;\n\t\t\tconst oDistinctValueMap: any = {};\n\t\t\tconst oDistinctUnitMap: any = {};\n\t\t\tif (oInData.dataProperty && oInData.dataProperty.indexOf(\"/\") > -1) {\n\t\t\t\tconst aFinalPath = MassEditHelper.initLastLevelOfPropertyPath(oInData.dataProperty, aValues /*, dialogContext */);\n\t\t\t\tconst aPropertyPaths = oInData.dataProperty.split(\"/\");\n\n\t\t\t\tfor (const context of aContexts) {\n\t\t\t\t\tconst sMultiLevelPathValue = context.getObject(oInData.dataProperty);\n\t\t\t\t\tsPropertyKey = `${oInData.dataProperty}/${sMultiLevelPathValue}`;\n\t\t\t\t\tif (!oDistinctValueMap[sPropertyKey] && aFinalPath[aPropertyPaths[aPropertyPaths.length - 1]]) {\n\t\t\t\t\t\toTextInfo = MassEditHelper.getTextArrangementInfo(\n\t\t\t\t\t\t\toInData.dataProperty,\n\t\t\t\t\t\t\toInData.descriptionPath,\n\t\t\t\t\t\t\toInData.display,\n\t\t\t\t\t\t\tcontext\n\t\t\t\t\t\t);\n\t\t\t\t\t\taFinalPath[aPropertyPaths[aPropertyPaths.length - 1]].push({\n\t\t\t\t\t\t\ttext: (oTextInfo && oTextInfo.fullText) || sMultiLevelPathValue,\n\t\t\t\t\t\t\tkey: sPropertyKey,\n\t\t\t\t\t\t\ttextInfo: oTextInfo\n\t\t\t\t\t\t});\n\t\t\t\t\t\toDistinctValueMap[sPropertyKey] = sMultiLevelPathValue;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// if (Object.keys(oDistinctValueMap).length === 1) {\n\t\t\t\t// \tdialogContext.setProperty(oData.dataProperty, sPropertyKey && oDistinctValueMap[sPropertyKey]);\n\t\t\t\t// }\n\n\t\t\t\taFinalPath[aPropertyPaths[aPropertyPaths.length - 1]].textInfo = {\n\t\t\t\t\tdescriptionPath: oInData.descriptionPath,\n\t\t\t\t\tvaluePath: oInData.dataProperty,\n\t\t\t\t\tdisplayMode: oInData.display\n\t\t\t\t};\n\t\t\t} else {\n\t\t\t\taValues[oInData.dataProperty] = aValues[oInData.dataProperty] || [];\n\t\t\t\taValues[oInData.dataProperty][\"selectOptions\"] = aValues[oInData.dataProperty][\"selectOptions\"] || [];\n\t\t\t\tif (oInData.unitProperty) {\n\t\t\t\t\taUnitData[oInData.unitProperty] = aUnitData[oInData.unitProperty] || [];\n\t\t\t\t\taUnitData[oInData.unitProperty][\"selectOptions\"] = aUnitData[oInData.unitProperty][\"selectOptions\"] || [];\n\t\t\t\t}\n\t\t\t\tfor (const context of aContexts) {\n\t\t\t\t\tconst oDataObject = context.getObject();\n\t\t\t\t\tsPropertyKey = `${oInData.dataProperty}/${oDataObject[oInData.dataProperty]}`;\n\t\t\t\t\tif (oInData.dataProperty && oDataObject[oInData.dataProperty] && !oDistinctValueMap[sPropertyKey]) {\n\t\t\t\t\t\tif (oInData.inputType != \"CheckBox\") {\n\t\t\t\t\t\t\toTextInfo = MassEditHelper.getTextArrangementInfo(\n\t\t\t\t\t\t\t\toInData.dataProperty,\n\t\t\t\t\t\t\t\toInData.descriptionPath,\n\t\t\t\t\t\t\t\toInData.display,\n\t\t\t\t\t\t\t\tcontext\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tconst entry = {\n\t\t\t\t\t\t\t\ttext: (oTextInfo && oTextInfo.fullText) || oDataObject[oInData.dataProperty],\n\t\t\t\t\t\t\t\tkey: sPropertyKey,\n\t\t\t\t\t\t\t\ttextInfo: oTextInfo\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\taValues[oInData.dataProperty].push(entry);\n\t\t\t\t\t\t\taValues[oInData.dataProperty][\"selectOptions\"].push(entry);\n\t\t\t\t\t\t}\n\t\t\t\t\t\toDistinctValueMap[sPropertyKey] = oDataObject[oInData.dataProperty];\n\t\t\t\t\t}\n\t\t\t\t\tif (oInData.unitProperty && oDataObject[oInData.unitProperty]) {\n\t\t\t\t\t\tsUnitPropertyName = `${oInData.unitProperty}/${oDataObject[oInData.unitProperty]}`;\n\t\t\t\t\t\tif (!oDistinctUnitMap[sUnitPropertyName]) {\n\t\t\t\t\t\t\tif (oInData.inputType != \"CheckBox\") {\n\t\t\t\t\t\t\t\toTextInfo = MassEditHelper.getTextArrangementInfo(\n\t\t\t\t\t\t\t\t\toInData.unitProperty,\n\t\t\t\t\t\t\t\t\toInData.descriptionPath,\n\t\t\t\t\t\t\t\t\toInData.display,\n\t\t\t\t\t\t\t\t\tcontext\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\tconst unitEntry = {\n\t\t\t\t\t\t\t\t\ttext: (oTextInfo && oTextInfo.fullText) || oDataObject[oInData.unitProperty],\n\t\t\t\t\t\t\t\t\tkey: sUnitPropertyName,\n\t\t\t\t\t\t\t\t\ttextInfo: oTextInfo\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\taUnitData[oInData.unitProperty].push(unitEntry);\n\t\t\t\t\t\t\t\taUnitData[oInData.unitProperty][\"selectOptions\"].push(unitEntry);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\toDistinctUnitMap[sUnitPropertyName] = oDataObject[oInData.unitProperty];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\taValues[oInData.dataProperty].textInfo = {\n\t\t\t\t\tdescriptionPath: oInData.descriptionPath,\n\t\t\t\t\tvaluePath: oInData.dataProperty,\n\t\t\t\t\tdisplayMode: oInData.display\n\t\t\t\t};\n\t\t\t\tif (Object.keys(oDistinctValueMap).length === 1) {\n\t\t\t\t\tdialogContext.setProperty(oInData.dataProperty, sPropertyKey && oDistinctValueMap[sPropertyKey]);\n\t\t\t\t}\n\t\t\t\tif (Object.keys(oDistinctUnitMap).length === 1) {\n\t\t\t\t\tdialogContext.setProperty(oInData.unitProperty, sUnitPropertyName && oDistinctUnitMap[sUnitPropertyName]);\n\t\t\t\t}\n\t\t\t}\n\t\t\ttextPaths[oInData.dataProperty] = oInData.descriptionPath ? [oInData.descriptionPath] : [];\n\t\t});\n\t\taDataArray.forEach(function (oInData: any) {\n\t\t\tlet values: any = {};\n\t\t\tif (oInData.dataProperty.indexOf(\"/\") > -1) {\n\t\t\t\tconst sMultiLevelPropPathValue = MassEditHelper.getValueForMultiLevelPath(oInData.dataProperty, aValues);\n\t\t\t\tif (!sMultiLevelPropPathValue) {\n\t\t\t\t\tsMultiLevelPropPathValue.push({ text: oDefaultValues.leaveBlankValue, key: `Empty/${oInData.dataProperty}` });\n\t\t\t\t} else {\n\t\t\t\t\tMassEditHelper.setDefaultValuesToDialog(sMultiLevelPropPathValue, oDefaultValues, oInData);\n\t\t\t\t}\n\t\t\t\tvalues = sMultiLevelPropPathValue;\n\t\t\t} else if (aValues[oInData.dataProperty]) {\n\t\t\t\taValues[oInData.dataProperty] = aValues[oInData.dataProperty] || [];\n\t\t\t\tMassEditHelper.setDefaultValuesToDialog(aValues[oInData.dataProperty], oDefaultValues, oInData);\n\t\t\t\tvalues = aValues[oInData.dataProperty];\n\t\t\t}\n\n\t\t\tif (aUnitData[oInData.unitProperty] && aUnitData[oInData.unitProperty].length) {\n\t\t\t\tMassEditHelper.setDefaultValuesToDialog(aUnitData[oInData.unitProperty], oDefaultValues, oInData, true);\n\t\t\t\taUnitData[oInData.unitProperty].textInfo = {};\n\t\t\t\taUnitData[oInData.unitProperty].selectedKey = MassEditHelper.getDefaultSelectionPathComboBox(\n\t\t\t\t\taContexts,\n\t\t\t\t\toInData.unitProperty\n\t\t\t\t);\n\t\t\t\taUnitData[oInData.unitProperty].inputType = oInData.inputType;\n\t\t\t} else if (\n\t\t\t\t(oInData.dataProperty && aValues[oInData.dataProperty] && !aValues[oInData.dataProperty].length) ||\n\t\t\t\t(oInData.unitProperty && aUnitData[oInData.unitProperty] && !aUnitData[oInData.unitProperty].length)\n\t\t\t) {\n\t\t\t\tconst bClearFieldOrBlankValueExists =\n\t\t\t\t\taValues[oInData.dataProperty] &&\n\t\t\t\t\taValues[oInData.dataProperty].some(function (obj: any) {\n\t\t\t\t\t\treturn obj.text === \"< Clear Values >\" || obj.text === \"< Leave Blank >\";\n\t\t\t\t\t});\n\t\t\t\tif (oInData.dataProperty && !bClearFieldOrBlankValueExists) {\n\t\t\t\t\taValues[oInData.dataProperty].push({ text: oDefaultValues.leaveBlankValue, key: `Empty/${oInData.dataProperty}` });\n\t\t\t\t}\n\t\t\t\tconst bClearFieldOrBlankUnitValueExists =\n\t\t\t\t\taUnitData[oInData.unitProperty] &&\n\t\t\t\t\taUnitData[oInData.unitProperty].some(function (obj: any) {\n\t\t\t\t\t\treturn obj.text === \"< Clear Values >\" || obj.text === \"< Leave Blank >\";\n\t\t\t\t\t});\n\t\t\t\tif (oInData.unitProperty) {\n\t\t\t\t\tif (!bClearFieldOrBlankUnitValueExists) {\n\t\t\t\t\t\taUnitData[oInData.unitProperty].push({\n\t\t\t\t\t\t\ttext: oDefaultValues.leaveBlankValue,\n\t\t\t\t\t\t\tkey: `Empty/${oInData.unitProperty}`\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t\taUnitData[oInData.unitProperty].textInfo = {};\n\t\t\t\t\taUnitData[oInData.unitProperty].selectedKey = MassEditHelper.getDefaultSelectionPathComboBox(\n\t\t\t\t\t\taContexts,\n\t\t\t\t\t\toInData.unitProperty\n\t\t\t\t\t);\n\t\t\t\t\taUnitData[oInData.unitProperty].inputType = oInData.inputType;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (oInData.isPropertyReadOnly && typeof oInData.isPropertyReadOnly === \"boolean\") {\n\t\t\t\taReadOnlyFieldInfo.push({ property: oInData.dataProperty, value: oInData.isPropertyReadOnly, type: \"Default\" });\n\t\t\t} else if (\n\t\t\t\toInData.isPropertyReadOnly &&\n\t\t\t\toInData.isPropertyReadOnly.operands &&\n\t\t\t\toInData.isPropertyReadOnly.operands[0] &&\n\t\t\t\toInData.isPropertyReadOnly.operands[0].operand1 &&\n\t\t\t\toInData.isPropertyReadOnly.operands[0].operand2\n\t\t\t) {\n\t\t\t\t// This needs to be refactored in accordance with the ReadOnlyExpression change\n\t\t\t\taReadOnlyFieldInfo.push({\n\t\t\t\t\tproperty: oInData.dataProperty,\n\t\t\t\t\tpropertyPath: oInData.isPropertyReadOnly.operands[0].operand1.path,\n\t\t\t\t\tpropertyValue: oInData.isPropertyReadOnly.operands[0].operand2.value,\n\t\t\t\t\ttype: \"Path\"\n\t\t\t\t});\n\t\t\t}\n\n\t\t\t// Setting visbility of the mass edit field.\n\t\t\tif (oInData.editMode) {\n\t\t\t\tvalues.visible =\n\t\t\t\t\toInData.editMode === EditMode.Editable ||\n\t\t\t\t\taContexts.some(\n\t\t\t\t\t\tMassEditHelper.getFieldVisiblity.bind(\n\t\t\t\t\t\t\tMassEditHelper,\n\t\t\t\t\t\t\toInData.editMode,\n\t\t\t\t\t\t\toDialogDataModel,\n\t\t\t\t\t\t\toInData.dataProperty,\n\t\t\t\t\t\t\tvalues\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tvalues.visible = true;\n\t\t\t}\n\t\t\tvalues.selectedKey = MassEditHelper.getDefaultSelectionPathComboBox(aContexts, oInData.dataProperty);\n\t\t\tvalues.inputType = oInData.inputType;\n\t\t\tvalues.unitProperty = oInData.unitProperty;\n\t\t});\n\n\t\treturn oDialogDataModel;\n\t},\n\t/**\n\t * Gets transient context for dialog.\n\t *\n\t * @param table Instance of Table.\n\t * @param dialog Mass Edit Dialog.\n\t * @returns Promise returning instance of dialog.\n\t */\n\tgetDialogContext: function (table: Table, dialog?: Dialog): Context {\n\t\tlet transCtx: Context = (dialog && dialog.getBindingContext()) as Context;\n\n\t\tif (!transCtx) {\n\t\t\tconst model = table.getModel();\n\t\t\tconst listBinding = table.getRowBinding();\n\t\t\tconst transientListBinding = model.bindList(listBinding.getPath(), listBinding.getContext(), [], [], {\n\t\t\t\t$$updateGroupId: \"submitLater\"\n\t\t\t}) as ODataListBinding;\n\t\t\t(transientListBinding as any).refreshInternal = function () {\n\t\t\t\t/* */\n\t\t\t};\n\t\t\ttransCtx = transientListBinding.create({}, true);\n\t\t}\n\n\t\treturn transCtx;\n\t},\n\n\tonDialogOpen: function (event: any): void {\n\t\tconst source = event.getSource();\n\t\tconst fieldsInfoModel = source.getModel(\"fieldsInfo\");\n\t\tfieldsInfoModel.setProperty(\"/isOpen\", true);\n\t},\n\n\tcloseDialog: function (oDialog: any) {\n\t\toDialog.close();\n\t\toDialog.destroy();\n\t},\n\n\tmessageHandlingForMassEdit: async function (\n\t\toTable: Table,\n\t\taContexts: any,\n\t\toController: PageController,\n\t\toInDialog: any,\n\t\taResults: any,\n\t\terrorContexts: any\n\t) {\n\t\tconst DraftStatus = FELibrary.DraftStatus;\n\t\tconst oResourceBundle = Core.getLibraryResourceBundle(\"sap.fe.core\");\n\t\t(oController.getView()?.getBindingContext(\"internal\") as InternalModelContext)?.setProperty(\"getBoundMessagesForMassEdit\", true);\n\t\toController._editFlow.getMessageHandler().showMessages({\n\t\t\tonBeforeShowMessage: function (messages: any, showMessageParameters: any) {\n\t\t\t\t//messages.concatenate(messageHandling.getMessages(true, true));\n\t\t\t\tshowMessageParameters.fnGetMessageSubtitle = messageHandling.setMessageSubtitle.bind({}, oTable, aContexts);\n\t\t\t\tconst unboundErrors: any[] = [];\n\t\t\t\tmessages.forEach(function (message: any) {\n\t\t\t\t\tif (!message.getTarget()) {\n\t\t\t\t\t\tunboundErrors.push(message);\n\t\t\t\t\t}\n\t\t\t\t});\n\n\t\t\t\tif (aResults.length > 0 && errorContexts.length === 0) {\n\t\t\t\t\toController._editFlow.setDraftStatus(DraftStatus.Saved);\n\t\t\t\t\tconst successToast = oResourceBundle.getText(\"C_MASS_EDIT_SUCCESS_TOAST\");\n\t\t\t\t\tMessageToast.show(successToast);\n\t\t\t\t} else if (errorContexts.length < (oTable as any).getSelectedContexts().length) {\n\t\t\t\t\toController._editFlow.setDraftStatus(DraftStatus.Saved);\n\t\t\t\t} else if (errorContexts.length === (oTable as any).getSelectedContexts().length) {\n\t\t\t\t\toController._editFlow.setDraftStatus(DraftStatus.Clear);\n\t\t\t\t}\n\n\t\t\t\tif (oController.getModel(\"ui\").getProperty(\"/isEditable\") && unboundErrors.length === 0) {\n\t\t\t\t\tshowMessageParameters.showMessageBox = false;\n\t\t\t\t\tshowMessageParameters.showMessageDialog = false;\n\t\t\t\t}\n\t\t\t\treturn showMessageParameters;\n\t\t\t}\n\t\t});\n\t\tif (oInDialog.isOpen()) {\n\t\t\tMassEditHelper.closeDialog(oInDialog);\n\t\t\t(oController.getView()?.getBindingContext(\"internal\") as InternalModelContext)?.setProperty(\"skipPatchHandlers\", false);\n\t\t}\n\t\t(oController.getView()?.getBindingContext(\"internal\") as InternalModelContext)?.setProperty(\"getBoundMessagesForMassEdit\", false);\n\t},\n\n\t/**\n\t * This function generates side effects map from side effects ids(which is a combination of entity type and qualifier).\n\t *\n\t * @param oEntitySetContext\n\t * @param aSideEffects\n\t * @param oController\n\t * @param aResults\n\t * @returns Side effect map with data.\n\t */\n\tgetSideEffectDataForKey: function (oEntitySetContext: any, aSideEffects: any, oController: PageController, aResults: any) {\n\t\tconst sOwnerEntityType = oEntitySetContext.getProperty(\"$Type\");\n\t\tconst baseSideEffectsMapArray: any = {};\n\n\t\taResults.forEach((result: any) => {\n\t\t\tconst sPath = result.keyValue;\n\t\t\tconst sideEffectsArray = FieldHelper.getSideEffectsOnEntityAndProperty(sPath, sOwnerEntityType, aSideEffects);\n\t\t\tbaseSideEffectsMapArray[sPath] = oController._sideEffects.getSideEffectsMapForFieldGroups(sideEffectsArray);\n\t\t});\n\t\treturn baseSideEffectsMapArray;\n\t},\n\n\t/**\n\t * Give the entity type for a given spath for e.g.RequestedQuantity.\n\t *\n\t * @param sPath\n\t * @param sEntityType\n\t * @param oMetaModel\n\t * @returns Object having entity, spath and navigation path.\n\t */\n\tfnGetPathForSourceProperty: function (sPath: any, sEntityType: any, oMetaModel: any) {\n\t\t// if the property path has a navigation, get the target entity type of the navigation\n\t\tconst sNavigationPath =\n\t\t\t\tsPath.indexOf(\"/\") > 0 ? \"/\" + sEntityType + \"/\" + sPath.substr(0, sPath.lastIndexOf(\"/\") + 1) + \"@sapui.name\" : false,\n\t\t\tpOwnerEntity = !sNavigationPath ? Promise.resolve(sEntityType) : oMetaModel.requestObject(sNavigationPath);\n\t\tsPath = sNavigationPath ? sPath.substr(sPath.lastIndexOf(\"/\") + 1) : sPath;\n\t\treturn { sPath, pOwnerEntity, sNavigationPath };\n\t},\n\n\tfnGetEntityTypeOfOwner: function (oMetaModel: any, baseNavPath: string, oEntitySetContext: any, targetEntity: string, aTargets: any) {\n\t\tconst ownerEntityType = oEntitySetContext.getProperty(\"$Type\");\n\t\tconst { $Type: pOwner, $Partner: ownerNavPath } = oMetaModel.getObject(`${oEntitySetContext}/${baseNavPath}`); // nav path\n\t\tif (ownerNavPath) {\n\t\t\tconst entityObjOfOwnerPartner = oMetaModel.getObject(`/${pOwner}/${ownerNavPath}`);\n\t\t\tif (entityObjOfOwnerPartner) {\n\t\t\t\tconst entityTypeOfOwnerPartner = entityObjOfOwnerPartner[\"$Type\"];\n\t\t\t\t// if the entity types defer, then base nav path is not from owner\n\t\t\t\tif (entityTypeOfOwnerPartner !== ownerEntityType) {\n\t\t\t\t\t// if target Prop is not from owner, we add it as immediate\n\t\t\t\t\taTargets.push(targetEntity);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\t// if there is no $Partner attribute, it may not be from owner\n\t\t\taTargets.push(targetEntity);\n\t\t}\n\t\treturn aTargets;\n\t},\n\n\t/**\n\t * Give targets that are immediate or deferred based on the entity type of that target.\n\t *\n\t *\n\t * @param sideEffectsData\n\t * @param oEntitySetContext\n\t * @param sEntityType\n\t * @param oMetaModel\n\t * @returns Targets to request side effects.\n\t */\n\tfnGetTargetsForMassEdit: function (sideEffectsData: any, oEntitySetContext: any, sEntityType: any, oMetaModel: any) {\n\t\tconst { TargetProperties: aTargetProperties, TargetEntities: aTargetEntities } = sideEffectsData;\n\t\tconst aPromises: any = [];\n\t\tlet aTargets: any = [];\n\t\tconst ownerEntityType = oEntitySetContext.getProperty(\"$Type\");\n\n\t\tif (sEntityType === ownerEntityType) {\n\t\t\t// if SalesOrdr Item\n\t\t\taTargetEntities?.forEach((targetEntity: any) => {\n\t\t\t\ttargetEntity = targetEntity[\"$NavigationPropertyPath\"];\n\t\t\t\tlet baseNavPath: string;\n\t\t\t\tif (targetEntity.includes(\"/\")) {\n\t\t\t\t\tbaseNavPath = targetEntity.split(\"/\")[0];\n\t\t\t\t} else {\n\t\t\t\t\tbaseNavPath = targetEntity;\n\t\t\t\t}\n\t\t\t\taTargets = MassEditHelper.fnGetEntityTypeOfOwner(oMetaModel, baseNavPath, oEntitySetContext, targetEntity, aTargets);\n\t\t\t});\n\t\t}\n\n\t\tif (aTargetProperties.length) {\n\t\t\taTargetProperties.forEach((targetProp: any) => {\n\t\t\t\tconst { pOwnerEntity } = MassEditHelper.fnGetPathForSourceProperty(targetProp, sEntityType, oMetaModel);\n\t\t\t\taPromises.push(\n\t\t\t\t\tpOwnerEntity.then((resultEntity: any) => {\n\t\t\t\t\t\t// if entity is SalesOrderItem, Target Property is from Items table\n\t\t\t\t\t\tif (resultEntity === ownerEntityType) {\n\t\t\t\t\t\t\taTargets.push(targetProp); // get immediate targets\n\t\t\t\t\t\t} else if (targetProp.includes(\"/\")) {\n\t\t\t\t\t\t\tconst baseNavPath = targetProp.split(\"/\")[0];\n\t\t\t\t\t\t\taTargets = MassEditHelper.fnGetEntityTypeOfOwner(\n\t\t\t\t\t\t\t\toMetaModel,\n\t\t\t\t\t\t\t\tbaseNavPath,\n\t\t\t\t\t\t\t\toEntitySetContext,\n\t\t\t\t\t\t\t\ttargetProp,\n\t\t\t\t\t\t\t\taTargets\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn Promise.resolve(aTargets);\n\t\t\t\t\t})\n\t\t\t\t);\n\t\t\t});\n\t\t} else {\n\t\t\taPromises.push(Promise.resolve(aTargets));\n\t\t}\n\n\t\treturn Promise.all(aPromises);\n\t},\n\n\t/**\n\t * This function checks if in the given side Effects Obj, if _Item is set as Target Entity for any side Effects on\n\t * other entity set.\n\t *\n\t * @param sideEffectsMap\n\t * @param oEntitySetContext\n\t * @returns Length of sideEffectsArray where current Entity is set as Target Entity\n\t */\n\tcheckIfEntityExistsAsTargetEntity: (\n\t\tsideEffectsMap: MassEditFieldSideEffectDictionary | FieldSideEffectDictionary,\n\t\toEntitySetContext: Context\n\t) => {\n\t\tconst ownerEntityType = oEntitySetContext.getProperty(\"$Type\");\n\t\tconst sideEffectsOnOtherEntity: MassEditFieldSideEffectPropertyType[] = Object.values(sideEffectsMap).filter(\n\t\t\t(obj: MassEditFieldSideEffectPropertyType) => {\n\t\t\t\treturn obj.name.indexOf(ownerEntityType) == -1;\n\t\t\t}\n\t\t);\n\n\t\tconst entitySetName = oEntitySetContext.getPath().split(\"/\").pop();\n\t\tconst sideEffectsWithCurrentEntityAsTarget = sideEffectsOnOtherEntity.filter((obj: MassEditFieldSideEffectPropertyType) => {\n\t\t\tconst targetEntitiesArray: SideEffectsTargetEntityType[] | undefined = obj.sideEffects.TargetEntities;\n\t\t\treturn targetEntitiesArray?.filter(\n\t\t\t\t(innerObj: SideEffectsTargetEntityType) => innerObj[\"$NavigationPropertyPath\"] === entitySetName\n\t\t\t).length\n\t\t\t\t? obj\n\t\t\t\t: false;\n\t\t});\n\t\treturn sideEffectsWithCurrentEntityAsTarget.length;\n\t},\n\n\t/**\n\t * Upon updating the field, array of immediate and deferred side effects for that field are created.\n\t * If there are any failed side effects for that context, they will also be used to generate the map.\n\t * If the field has text associated with it, then add it to request side effects.\n\t *\n\t * @param mParams\n\t * @param mParams.oController Controller\n\t * @param mParams.oFieldPromise Promise to update field\n\t * @param mParams.sideEffectMap SideEffectsMap for the field\n\t * @param mParams.textPaths TextPaths of the field if any\n\t * @param mParams.groupId Group Id to used to group requests\n\t * @param mParams.key KeyValue of the field\n\t * @param mParams.oEntitySetContext EntitySetcontext\n\t * @param mParams.oMetaModel Metamodel data\n\t * @param mParams.selectedContext Selected row context\n\t * @param mParams.deferredTargetsForAQualifiedName Deferred targets data\n\t * @returns Promise for all immediately requested side effects.\n\t */\n\thandleMassEditFieldUpdateAndRequestSideEffects: async function (mParams: DataToUpdateFieldAndSideEffectsType) {\n\t\tconst {\n\t\t\toController,\n\t\t\toFieldPromise,\n\t\t\tsideEffectsMap,\n\t\t\ttextPaths,\n\t\t\tgroupId,\n\t\t\tkey,\n\t\t\toEntitySetContext,\n\t\t\toMetaModel,\n\t\t\toSelectedContext,\n\t\t\tdeferredTargetsForAQualifiedName\n\t\t} = mParams;\n\t\tconst immediateSideEffectsPromises = [oFieldPromise];\n\t\tconst ownerEntityType = oEntitySetContext.getProperty(\"$Type\");\n\t\tconst oAppComponent = CommonUtils.getAppComponent(oController.getView());\n\t\tconst oSideEffectsService = oAppComponent.getSideEffectsService();\n\n\t\tconst isSideEffectsWithCurrentEntityAsTarget = MassEditHelper.checkIfEntityExistsAsTargetEntity(sideEffectsMap, oEntitySetContext);\n\n\t\tif (sideEffectsMap) {\n\t\t\tconst allEntityTypesWithQualifier = Object.keys(sideEffectsMap);\n\t\t\tconst sideEffectsDataForField: any = Object.values(sideEffectsMap);\n\n\t\t\tconst mVisitedSideEffects: any = {};\n\t\t\tdeferredTargetsForAQualifiedName[key] = {};\n\t\t\tfor (const [index, data] of sideEffectsDataForField.entries()) {\n\t\t\t\tconst entityTypeWithQualifier = allEntityTypesWithQualifier[index];\n\t\t\t\tconst sEntityType = entityTypeWithQualifier.split(\"#\")[0];\n\t\t\t\tconst oContext: any = oController._sideEffects.getContextForSideEffects(oSelectedContext, sEntityType);\n\t\t\t\tdata.context = oContext;\n\n\t\t\t\tconst allFailedSideEffects = oController._sideEffects.getRegisteredFailedRequests();\n\t\t\t\tconst aFailedSideEffects = allFailedSideEffects[oContext.getPath()];\n\t\t\t\toController._sideEffects.unregisterFailedSideEffectsForAContext(oContext);\n\t\t\t\tlet sideEffectsForCurrentContext = [data.sideEffects];\n\t\t\t\tsideEffectsForCurrentContext =\n\t\t\t\t\taFailedSideEffects && aFailedSideEffects.length\n\t\t\t\t\t\t? sideEffectsForCurrentContext.concat(aFailedSideEffects)\n\t\t\t\t\t\t: sideEffectsForCurrentContext;\n\t\t\t\tmVisitedSideEffects[oContext] = {};\n\t\t\t\tfor (const aSideEffect of sideEffectsForCurrentContext) {\n\t\t\t\t\tif (!mVisitedSideEffects[oContext].hasOwnProperty(aSideEffect.fullyQualifiedName)) {\n\t\t\t\t\t\tmVisitedSideEffects[oContext][aSideEffect.fullyQualifiedName] = true;\n\t\t\t\t\t\tlet aImmediateTargets: any[] = [],\n\t\t\t\t\t\t\tallTargets: any[] = [],\n\t\t\t\t\t\t\ttriggerActionName: String | undefined;\n\n\t\t\t\t\t\tconst fnGetImmediateTargetsAndActions = async function (mSideEffect: SideEffectsType) {\n\t\t\t\t\t\t\tconst { TargetProperties: aTargetProperties, TargetEntities: aTargetEntities } = mSideEffect;\n\t\t\t\t\t\t\tconst sideEffectEntityType = mSideEffect.fullyQualifiedName.split(\"@\")[0];\n\t\t\t\t\t\t\tconst targetsArrayForAllProperties = await MassEditHelper.fnGetTargetsForMassEdit(\n\t\t\t\t\t\t\t\tmSideEffect,\n\t\t\t\t\t\t\t\toEntitySetContext,\n\t\t\t\t\t\t\t\tsideEffectEntityType,\n\t\t\t\t\t\t\t\toMetaModel\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\taImmediateTargets = targetsArrayForAllProperties[0];\n\t\t\t\t\t\t\tallTargets = (aTargetProperties || []).concat((aTargetEntities as any[]) || []);\n\n\t\t\t\t\t\t\tconst actionName: string | undefined = (mSideEffect as ODataSideEffectsType).TriggerAction;\n\t\t\t\t\t\t\tconst aDeferredTargets = allTargets.filter((target: any) => {\n\t\t\t\t\t\t\t\treturn !aImmediateTargets.includes(target);\n\t\t\t\t\t\t\t});\n\n\t\t\t\t\t\t\tdeferredTargetsForAQualifiedName[key][mSideEffect.fullyQualifiedName] = {\n\t\t\t\t\t\t\t\taTargets: aDeferredTargets,\n\t\t\t\t\t\t\t\toContext: oContext,\n\t\t\t\t\t\t\t\tmSideEffect\n\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t// if entity is other than items table then action is defered\n\t\t\t\t\t\t\tif (actionName && sideEffectEntityType === ownerEntityType) {\n\t\t\t\t\t\t\t\t// static action is on collection, so we defer it, else add to immediate requests array\n\t\t\t\t\t\t\t\tconst isStaticAction = TableHelper._isStaticAction(oMetaModel.getObject(`/${actionName}`), actionName);\n\t\t\t\t\t\t\t\tif (!isStaticAction) {\n\t\t\t\t\t\t\t\t\ttriggerActionName = actionName;\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tdeferredTargetsForAQualifiedName[key][mSideEffect.fullyQualifiedName][\"TriggerAction\"] = actionName;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tdeferredTargetsForAQualifiedName[key][mSideEffect.fullyQualifiedName][\"TriggerAction\"] = actionName;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif (isSideEffectsWithCurrentEntityAsTarget) {\n\t\t\t\t\t\t\t\taImmediateTargets = [];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\taTargets: aImmediateTargets,\n\t\t\t\t\t\t\t\tTriggerAction: triggerActionName\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t};\n\t\t\t\t\t\timmediateSideEffectsPromises.push(\n\t\t\t\t\t\t\toController._sideEffects.requestSideEffects(aSideEffect, oContext, groupId, fnGetImmediateTargetsAndActions)\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (textPaths?.[key] && textPaths[key].length) {\n\t\t\timmediateSideEffectsPromises.push(oSideEffectsService.requestSideEffects(textPaths[key], oSelectedContext, groupId));\n\t\t}\n\t\treturn (Promise as any).allSettled(immediateSideEffectsPromises);\n\t},\n\n\t/**\n\t * Create the mass edit dialog.\n\t *\n\t * @param oTable Instance of Table\n\t * @param aContexts Contexts for mass edit\n\t * @param oController Controller for the view\n\t * @returns Promise returning instance of dialog.\n\t */\n\tcreateDialog: async function (oTable: Table, aContexts: any[], oController: PageController): Promise<any> {\n\t\tconst sFragmentName = \"sap/fe/core/controls/massEdit/MassEditDialog\",\n\t\t\taDataArray: any[] = [],\n\t\t\toResourceBundle = Core.getLibraryResourceBundle(\"sap.fe.core\"),\n\t\t\toDefaultValues = MassEditHelper.getDefaultTextsForDialog(oResourceBundle, aContexts.length, oTable),\n\t\t\toDataFieldModel = MassEditHelper.prepareDataForDialog(oTable, aContexts, aDataArray),\n\t\t\tdialogContext = MassEditHelper.getDialogContext(oTable),\n\t\t\toDialogDataModel = MassEditHelper.setRuntimeModelOnDialog(aContexts, aDataArray, oDefaultValues, dialogContext),\n\t\t\tmodel = oTable.getModel(),\n\t\t\tmetaModel = model.getMetaModel() as ODataMetaModel,\n\t\t\titemsModel = new TemplateModel(oDataFieldModel.getData(), metaModel);\n\n\t\tconst oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, \"fragment\");\n\n\t\tconst oCreatedFragment = await Promise.resolve(\n\t\t\tXMLPreprocessor.process(\n\t\t\t\toFragment,\n\t\t\t\t{ name: sFragmentName },\n\t\t\t\t{\n\t\t\t\t\tbindingContexts: {\n\t\t\t\t\t\tdataFieldModel: itemsModel.createBindingContext(\"/\"),\n\t\t\t\t\t\tmetaModel: metaModel.createBindingContext(\"/\"),\n\t\t\t\t\t\tcontextPath: metaModel.createBindingContext(metaModel.getMetaPath(dialogContext.getPath()))\n\t\t\t\t\t},\n\t\t\t\t\tmodels: {\n\t\t\t\t\t\tdataFieldModel: itemsModel,\n\t\t\t\t\t\tmetaModel: metaModel,\n\t\t\t\t\t\tcontextPath: metaModel\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t)\n\t\t);\n\t\tconst oDialogContent = await Fragment.load({ definition: oCreatedFragment });\n\t\tconst oDialog = new Dialog({\n\t\t\tresizable: true,\n\t\t\ttitle: oDefaultValues.massEditTitle,\n\t\t\tcontent: [oDialogContent as any],\n\t\t\tafterOpen: MassEditHelper.onDialogOpen,\n\t\t\tbeginButton: new Button({\n\t\t\t\ttext: MassEditHelper.helpers.getExpBindingForApplyButtonTxt(oDefaultValues, oDataFieldModel.getObject(\"/\")),\n\t\t\t\ttype: \"Emphasized\",\n\t\t\t\tpress: async function (oEvent: any) {\n\t\t\t\t\tmessageHandling.removeBoundTransitionMessages();\n\t\t\t\t\tmessageHandling.removeUnboundTransitionMessages();\n\t\t\t\t\t(oController.getView()?.getBindingContext(\"internal\") as InternalModelContext)?.setProperty(\"skipPatchHandlers\", true);\n\t\t\t\t\tconst oInDialog = oEvent.getSource().getParent();\n\t\t\t\t\tconst oModel = oInDialog.getModel(\"fieldsInfo\");\n\t\t\t\t\tconst aResults = oModel.getProperty(\"/results\");\n\n\t\t\t\t\tconst oMetaModel = oTable && (oTable.getModel().getMetaModel() as any),\n\t\t\t\t\t\tsCurrentEntitySetName = oTable.data(\"metaPath\"),\n\t\t\t\t\t\toEntitySetContext = oMetaModel.getContext(sCurrentEntitySetName);\n\t\t\t\t\tconst aSideEffects = await SideEffectsHelper.generateSideEffectsMapFromMetaModel(oMetaModel);\n\t\t\t\t\tconst errorContexts: any[] = [];\n\t\t\t\t\tconst textPaths = oModel.getProperty(\"/textPaths\");\n\t\t\t\t\tconst aPropertyReadableInfo = oModel.getProperty(\"/readablePropertyData\");\n\t\t\t\t\tlet groupId: string;\n\t\t\t\t\tlet allSideEffects: any[];\n\t\t\t\t\tconst massEditPromises: any = [];\n\t\t\t\t\tconst failedFieldsData: any = {};\n\t\t\t\t\tconst selectedRowsLength = aContexts.length;\n\t\t\t\t\tconst deferredTargetsForAQualifiedName: any = {};\n\t\t\t\t\tconst baseSideEffectsMapArray = MassEditHelper.getSideEffectDataForKey(\n\t\t\t\t\t\toEntitySetContext,\n\t\t\t\t\t\taSideEffects,\n\t\t\t\t\t\toController,\n\t\t\t\t\t\taResults\n\t\t\t\t\t);\n\t\t\t\t\t//const changePromise: any[] = [];\n\t\t\t\t\t//let bReadOnlyField = false;\n\t\t\t\t\t//const errorContexts: object[] = [];\n\n\t\t\t\t\taContexts.forEach(function (oSelectedContext: any, idx: number) {\n\t\t\t\t\t\tallSideEffects = [];\n\t\t\t\t\t\taResults.forEach(async function (oResult: any) {\n\t\t\t\t\t\t\tif (!failedFieldsData.hasOwnProperty(oResult.keyValue)) {\n\t\t\t\t\t\t\t\tfailedFieldsData[oResult.keyValue] = 0;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t//TODO - Add save implementation for Value Help.\n\t\t\t\t\t\t\tif (baseSideEffectsMapArray[oResult.keyValue]) {\n\t\t\t\t\t\t\t\tallSideEffects[oResult.keyValue] = baseSideEffectsMapArray[oResult.keyValue];\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif (aPropertyReadableInfo) {\n\t\t\t\t\t\t\t\taPropertyReadableInfo.some(function (oPropertyInfo: any) {\n\t\t\t\t\t\t\t\t\tif (oResult.keyValue === oPropertyInfo.property) {\n\t\t\t\t\t\t\t\t\t\tif (oPropertyInfo.type === \"Default\") {\n\t\t\t\t\t\t\t\t\t\t\treturn oPropertyInfo.value === true;\n\t\t\t\t\t\t\t\t\t\t} else if (\n\t\t\t\t\t\t\t\t\t\t\toPropertyInfo.type === \"Path\" &&\n\t\t\t\t\t\t\t\t\t\t\toPropertyInfo.propertyValue &&\n\t\t\t\t\t\t\t\t\t\t\toPropertyInfo.propertyPath\n\t\t\t\t\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t\t\t\t\treturn oSelectedContext.getObject(oPropertyInfo.propertyPath) === oPropertyInfo.propertyValue;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tgroupId = `$auto.${idx}`;\n\t\t\t\t\t\t\tconst oFieldPromise = oSelectedContext\n\t\t\t\t\t\t\t\t.setProperty(oResult.keyValue, oResult.value, groupId)\n\t\t\t\t\t\t\t\t.catch(function (oError: any) {\n\t\t\t\t\t\t\t\t\terrorContexts.push(oSelectedContext.getObject());\n\t\t\t\t\t\t\t\t\tLog.error(\"Mass Edit: Something went wrong in updating entries.\", oError);\n\t\t\t\t\t\t\t\t\tfailedFieldsData[oResult.keyValue] = failedFieldsData[oResult.keyValue] + 1;\n\t\t\t\t\t\t\t\t\treturn Promise.reject({ isFieldUpdateFailed: true });\n\t\t\t\t\t\t\t\t});\n\n\t\t\t\t\t\t\tconst dataToUpdateFieldAndSideEffects: DataToUpdateFieldAndSideEffectsType = {\n\t\t\t\t\t\t\t\toController,\n\t\t\t\t\t\t\t\toFieldPromise,\n\t\t\t\t\t\t\t\tsideEffectsMap: baseSideEffectsMapArray[oResult.keyValue],\n\t\t\t\t\t\t\t\ttextPaths,\n\t\t\t\t\t\t\t\tgroupId,\n\t\t\t\t\t\t\t\tkey: oResult.keyValue,\n\t\t\t\t\t\t\t\toEntitySetContext,\n\t\t\t\t\t\t\t\toMetaModel,\n\t\t\t\t\t\t\t\toSelectedContext,\n\t\t\t\t\t\t\t\tdeferredTargetsForAQualifiedName\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tmassEditPromises.push(\n\t\t\t\t\t\t\t\tMassEditHelper.handleMassEditFieldUpdateAndRequestSideEffects(dataToUpdateFieldAndSideEffects)\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\n\t\t\t\t\tawait (Promise as any)\n\t\t\t\t\t\t.allSettled(massEditPromises)\n\t\t\t\t\t\t.then(async function () {\n\t\t\t\t\t\t\tgroupId = `$auto.massEditDeferred`;\n\t\t\t\t\t\t\tconst deferredRequests = [];\n\t\t\t\t\t\t\tconst sideEffectsDataForAllKeys: any = Object.values(deferredTargetsForAQualifiedName);\n\t\t\t\t\t\t\tconst keysWithSideEffects: any[] = Object.keys(deferredTargetsForAQualifiedName);\n\n\t\t\t\t\t\t\tsideEffectsDataForAllKeys.forEach((aSideEffect: any, index: any) => {\n\t\t\t\t\t\t\t\tconst currentKey = keysWithSideEffects[index];\n\t\t\t\t\t\t\t\tif (failedFieldsData[currentKey] !== selectedRowsLength) {\n\t\t\t\t\t\t\t\t\tconst deferredSideEffectsData = Object.values(aSideEffect);\n\t\t\t\t\t\t\t\t\tdeferredSideEffectsData.forEach((req: any) => {\n\t\t\t\t\t\t\t\t\t\tconst { aTargets, oContext, TriggerAction, mSideEffect } = req;\n\t\t\t\t\t\t\t\t\t\tconst fnGetDeferredTargets = function () {\n\t\t\t\t\t\t\t\t\t\t\treturn aTargets;\n\t\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t\t\tconst fnGetDeferredTargetsAndActions = function () {\n\t\t\t\t\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\t\t\t\t\taTargets: fnGetDeferredTargets(),\n\t\t\t\t\t\t\t\t\t\t\t\tTriggerAction: TriggerAction\n\t\t\t\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\t\t\t};\n\n\t\t\t\t\t\t\t\t\t\tdeferredRequests.push(\n\t\t\t\t\t\t\t\t\t\t\t// if some deferred is rejected, it will be add to failed queue\n\t\t\t\t\t\t\t\t\t\t\toController._sideEffects.requestSideEffects(\n\t\t\t\t\t\t\t\t\t\t\t\tmSideEffect,\n\t\t\t\t\t\t\t\t\t\t\t\toContext,\n\t\t\t\t\t\t\t\t\t\t\t\tgroupId,\n\t\t\t\t\t\t\t\t\t\t\t\tfnGetDeferredTargetsAndActions\n\t\t\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.then(function () {\n\t\t\t\t\t\t\tMassEditHelper.messageHandlingForMassEdit(oTable, aContexts, oController, oInDialog, aResults, errorContexts);\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.catch((e: any) => {\n\t\t\t\t\t\t\tMassEditHelper.closeDialog(oDialog);\n\t\t\t\t\t\t\treturn Promise.reject(e);\n\t\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}),\n\t\t\tendButton: new Button({\n\t\t\t\ttext: oDefaultValues.cancelButtonText,\n\t\t\t\tvisible: MassEditHelper.helpers.hasEditableFieldsBinding(oDataFieldModel.getObject(\"/\"), true) as any,\n\t\t\t\tpress: function (oEvent: any) {\n\t\t\t\t\tconst oInDialog = oEvent.getSource().getParent();\n\t\t\t\t\tMassEditHelper.closeDialog(oInDialog);\n\t\t\t\t}\n\t\t\t})\n\t\t});\n\t\toDialog.setModel(oDialogDataModel, \"fieldsInfo\");\n\t\toDialog.setModel(model);\n\t\toDialog.setBindingContext(dialogContext);\n\t\treturn oDialog;\n\t},\n\n\thelpers: {\n\t\tgetBindingExpForHasEditableFields: (fields: any, editable: boolean) => {\n\t\t\tconst totalExp = fields.reduce(\n\t\t\t\t(expression: any, field: any) =>\n\t\t\t\t\tor(\n\t\t\t\t\t\texpression,\n\t\t\t\t\t\tpathInModel(\"/values/\" + field.dataProperty + \"/visible\", \"fieldsInfo\") as BindingToolkitExpression<boolean>\n\t\t\t\t\t),\n\t\t\t\tconstant(false)\n\t\t\t);\n\t\t\treturn editable ? totalExp : not(totalExp);\n\t\t},\n\n\t\tgetExpBindingForApplyButtonTxt: (defaultValues: any, fields: boolean) => {\n\t\t\tconst editableExp = MassEditHelper.helpers.getBindingExpForHasEditableFields(fields, true);\n\t\t\tconst totalExp = ifElse(editableExp, constant(defaultValues.applyButtonText), constant(defaultValues.okButtonText));\n\t\t\treturn compileExpression(totalExp);\n\t\t},\n\n\t\thasEditableFieldsBinding: (fields: any, editable: boolean) => {\n\t\t\treturn compileExpression(MassEditHelper.helpers.getBindingExpForHasEditableFields(fields, editable));\n\t\t}\n\t}\n};\n\nexport default MassEditHelper;\n"],"mappings":"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"}