@sap/open.fe 1.97.0 → 1.98.0

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

@@ -0,0 +1,679 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+        (c) Copyright 2009-2021 SAP SE. All rights reserved
+    
+ */
+sap.ui.define(
+	[
+		"sap/m/Dialog",
+		"sap/ui/core/XMLTemplateProcessor",
+		"sap/ui/model/json/JSONModel",
+		"sap/ui/core/Fragment",
+		"sap/ui/core/util/XMLPreprocessor",
+		"sap/fe/core/templating/UIFormatters",
+		"sap/fe/core/converters/MetaModelConverter",
+		"sap/fe/macros/field/FieldHelper",
+		"sap/fe/macros/field/FieldTemplating",
+		"sap/base/Log",
+		"sap/fe/core/CommonUtils",
+		"sap/fe/core/templating/FieldControlHelper"
+	],
+	function(
+		Dialog,
+		XMLTemplateProcessor,
+		JSONModel,
+		Fragment,
+		XMLPreprocessor,
+		UIFormatters,
+		MetaModelConverter,
+		FieldHelper,
+		FieldTemplating,
+		Log,
+		CommonUtils,
+		FieldControlHelper
+	) {
+		"use strict";
+
+		/* This class contains helpers to be used for mass edit functionality */
+
+		var 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 {string} sPath Property path
+			 * @param {Array} aValues Array instance where the default data needs to be added
+			 * @returns {Array}
+			 */
+			initLastLevelOfPropertyPath: function(sPath, aValues) {
+				var aFinalPath,
+					index = 0,
+					aPaths = sPath.split("/"),
+					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 {string} sValue Property value
+			 * @param {number} index Index of the property value
+			 * @param {Array} self Instance of the array
+			 * @returns {boolean}
+			 */
+			getUniqueValues: function(sValue, index, self) {
+				if (sValue) {
+					return self.indexOf(sValue) === index;
+				}
+			},
+
+			/**
+			 * 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 {string} sDataPropertyPath Property path
+			 * @param {object} oValues Object of property values
+			 * @returns {*}
+			 */
+			getValueForMultiLevelPath: function(sDataPropertyPath, oValues) {
+				if (sDataPropertyPath && sDataPropertyPath.indexOf("/") > 0) {
+					var aPropertyPaths = sDataPropertyPath.split("/"),
+						Result;
+					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 {Array} aContexts Contexts for mass edit
+			 * @param {string} sDataPropertyPath Data property path
+			 * @returns {string}
+			 */
+			getDefaultSelectionPathComboBox: function(aContexts, sDataPropertyPath) {
+				if (sDataPropertyPath && aContexts.length > 0) {
+					var oSelectedContext = aContexts,
+						aPropertyValues = [];
+					oSelectedContext.forEach(function(oContext) {
+						var oDataObject = oContext.getObject();
+						var sMultiLevelPathCondition =
+							sDataPropertyPath.indexOf("/") > -1 && oDataObject.hasOwnProperty(sDataPropertyPath.split("/")[0]);
+						if (oContext && (oDataObject.hasOwnProperty(sDataPropertyPath) || sMultiLevelPathCondition)) {
+							aPropertyValues.push(oContext.getObject(sDataPropertyPath));
+						}
+					});
+					var aUniquePropertyValues = aPropertyValues.filter(MassEditHelper.getUniqueValues);
+					if (aUniquePropertyValues.length > 1) {
+						return "Default/" + sDataPropertyPath;
+					} else if (aUniquePropertyValues.length === 0) {
+						return "Empty/" + sDataPropertyPath;
+					} else if (aUniquePropertyValues.length === 1) {
+						return sDataPropertyPath;
+					}
+				}
+			},
+
+			/**
+			 * Checks hidden annotation value [both static and path based] for table's selected context.
+			 *
+			 * @param {*} hiddenValue Hidden annotation value / path for field
+			 * @param {Array} aContexts Contexts for mass edit
+			 * @returns {boolean}
+			 */
+			getHiddenValueForContexts: function(hiddenValue, aContexts) {
+				if (hiddenValue && hiddenValue.$Path) {
+					return !aContexts.some(function(oSelectedContext) {
+						return oSelectedContext.getObject(hiddenValue.$Path) === false;
+					});
+				}
+				return hiddenValue;
+			},
+
+			/**
+			 * Initializes a JSON Model for properties of dialog fields [label, visiblity, dataproperty, etc.].
+			 *
+			 * @param {object} oTable Instance of Table
+			 * @param {Array} aContexts Contexts for mass edit
+			 * @param {Array} aDataArray Array containing data related to the dialog used by both the static and the runtime model
+			 * @returns {object}
+			 */
+			prepareDataForDialog: function(oTable, aContexts, aDataArray) {
+				var oMetaModel = oTable && oTable.getModel().getMetaModel(),
+					sCurrentEntitySetName = oTable.data("metaPath"),
+					aTableFields = MassEditHelper.getTableFields(oTable),
+					oEntityTypeContext = oMetaModel.getContext(sCurrentEntitySetName + "/@"),
+					oDataModelObjectPath = MetaModelConverter.getInvolvedDataModelObjects(oEntityTypeContext);
+
+				var oDataFieldModel = new JSONModel(),
+					oResult,
+					sLabelText,
+					bValueHelpEnabled,
+					sUnitPropertyPath,
+					bValueHelpEnabledForUnit,
+					bIsImmutable,
+					bIsComputed,
+					bChartProperty,
+					oTextBinding;
+
+				aTableFields.forEach(function(oColumnInfo) {
+					var sDataPropertyPath = oColumnInfo.dataProperty;
+					if (sDataPropertyPath) {
+						var oPropertyInfo =
+							sDataPropertyPath && oMetaModel.getObject(sCurrentEntitySetName + "/" + sDataPropertyPath + "@");
+						bValueHelpEnabled =
+							sDataPropertyPath &&
+							oMetaModel.getObject(sCurrentEntitySetName + "/" + sDataPropertyPath + "@") &&
+							oMetaModel.getObject(sCurrentEntitySetName + "/" + sDataPropertyPath + "@")[
+								"@com.sap.vocabularies.Common.v1.ValueList"
+							];
+						sUnitPropertyPath =
+							(oPropertyInfo &&
+								oPropertyInfo["@Org.OData.Measures.V1.Unit"] &&
+								oPropertyInfo["@Org.OData.Measures.V1.Unit"].$Path) ||
+							(oPropertyInfo &&
+								oPropertyInfo["@Org.OData.Measures.V1.ISOCurrency"] &&
+								oPropertyInfo["@Org.OData.Measures.V1.ISOCurrency"].$Path);
+						sLabelText = oColumnInfo.label || (oPropertyInfo && oPropertyInfo["@com.sap.vocabularies.Common.v1.Label"]);
+						bValueHelpEnabledForUnit =
+							sUnitPropertyPath &&
+							oMetaModel.getObject(sCurrentEntitySetName + "/" + sUnitPropertyPath + "@") &&
+							oMetaModel.getObject(sCurrentEntitySetName + "/" + sUnitPropertyPath + "@")[
+								"@com.sap.vocabularies.Common.v1.ValueList"
+							];
+						if (oDataModelObjectPath) {
+							oDataModelObjectPath.targetObject = oDataModelObjectPath.targetEntityType.entityProperties.filter(function(
+								oProperty
+							) {
+								return oProperty.name === sDataPropertyPath;
+							});
+						}
+						oDataModelObjectPath.targetObject = oDataModelObjectPath.targetObject[0] || {};
+						oTextBinding = FieldTemplating.getTextBinding(oDataModelObjectPath, undefined, true) || {};
+						var oFieldContext = oMetaModel.getContext(oColumnInfo.annotationPath),
+							oDataFieldConverted = MetaModelConverter.convertMetaModelContext(oFieldContext),
+							oPropertyContext = oMetaModel.getContext(sCurrentEntitySetName + "/" + sDataPropertyPath + "@"),
+							oInterface = oPropertyContext && oPropertyContext.getInterface();
+						bIsImmutable =
+							oPropertyContext &&
+							oPropertyContext.getProperty() &&
+							oPropertyContext.getProperty()["@Org.OData.Core.V1.Immutable"];
+						bIsComputed =
+							oPropertyContext &&
+							oPropertyContext.getProperty() &&
+							oPropertyContext.getProperty()["@Org.OData.Core.V1.Computed"];
+						var bHiddenField =
+							MassEditHelper.getHiddenValueForContexts(
+								oFieldContext && oFieldContext.getObject()["@com.sap.vocabularies.UI.v1.Hidden"],
+								aContexts
+							) || false;
+						oInterface.context = {
+							getModel: function() {
+								return oInterface.getModel();
+							},
+							getPath: function() {
+								return sCurrentEntitySetName + "/" + sDataPropertyPath;
+							}
+						};
+						var oFieldControl = FieldHelper.fieldControl(sDataPropertyPath, oInterface);
+						oPropertyInfo =
+							(oDataFieldConverted && oDataFieldConverted.Value && oDataFieldConverted.Value.$target) ||
+							(oDataFieldConverted && oDataFieldConverted.Target && oDataFieldConverted.Target.$target);
+						var isReadOnlyExpression = FieldControlHelper.isReadOnlyExpression(oPropertyInfo);
+						bChartProperty = oPropertyInfo && oPropertyInfo.term && oPropertyInfo.term === "com.sap.vocabularies.UI.v1.Chart";
+						if (
+							sDataPropertyPath &&
+							!bHiddenField &&
+							!bIsImmutable &&
+							!bIsComputed &&
+							!bChartProperty &&
+							UIFormatters.getEditableExpression(oPropertyInfo, oDataFieldConverted, oDataModelObjectPath) !== "false"
+						) {
+							oResult = {
+								"label": sLabelText + ":",
+								"visible":
+									sDataPropertyPath &&
+									!bHiddenField &&
+									!bIsImmutable &&
+									!bIsComputed &&
+									UIFormatters.getEditableExpression(oPropertyInfo, oDataFieldConverted, oDataModelObjectPath),
+								"dataProperty": sDataPropertyPath,
+								"isValueHelpEnabled": bValueHelpEnabled ? bValueHelpEnabled : false,
+								"unitProperty": sUnitPropertyPath ? sUnitPropertyPath : false,
+								"isValueHelpEnabledForUnit": bValueHelpEnabledForUnit ? bValueHelpEnabledForUnit : false,
+								"propertyPathForValueHelp": sCurrentEntitySetName + "/" + sDataPropertyPath,
+								"propertyPathForValueHelpUnit": sCurrentEntitySetName + "/" + sUnitPropertyPath,
+								"isFieldRequired": FieldHelper.getRequiredForDataField(oFieldControl, "Editable"),
+								"defaultSelectionPath": sDataPropertyPath
+									? MassEditHelper.getDefaultSelectionPathComboBox(aContexts, sDataPropertyPath)
+									: false,
+								"defaultSelectionUnitPath": sUnitPropertyPath
+									? MassEditHelper.getDefaultSelectionPathComboBox(aContexts, sUnitPropertyPath)
+									: false,
+								"entitySet": sCurrentEntitySetName,
+								"textBinding": oTextBinding,
+								"nullable": oPropertyInfo.nullable !== undefined ? oPropertyInfo.nullable : true,
+								"isPropertyReadOnly": isReadOnlyExpression !== undefined ? isReadOnlyExpression : false
+							};
+							aDataArray.push(oResult);
+						}
+					}
+				});
+				oDataFieldModel.setData(aDataArray);
+				return oDataFieldModel;
+			},
+
+			getInputTypeForColumn: function(oColumn) {
+				return (
+					oColumn.getTemplate().getContent &&
+					oColumn.getTemplate().getContent().getContentEdit &&
+					oColumn
+						.getTemplate()
+						.getContent()
+						.getContentEdit() &&
+					oColumn
+						.getTemplate()
+						.getContent()
+						.getContentEdit()[0] &&
+					oColumn
+						.getTemplate()
+						.getContent()
+						.getContentEdit()[0]
+						.getMetadata()
+						.getName()
+				);
+			},
+
+			getTableFields: function(oTable) {
+				var aColumns = (oTable && oTable.getColumns()) || [];
+				return aColumns.map(function(oColumn) {
+					var sDataProperty = oColumn && oColumn.getDataProperty(),
+						aRealtedColumnInfo =
+							oTable.data("columns") &&
+							oTable.data("columns").customData.filter(function(oColumnInfo) {
+								return oColumnInfo.name === sDataProperty && oColumnInfo.type === "Annotation";
+							});
+					return {
+						"dataProperty": sDataProperty,
+						"label": oColumn.getHeader(),
+						"annotationPath": aRealtedColumnInfo && aRealtedColumnInfo[0] && aRealtedColumnInfo[0].annotationPath,
+						"inputType": MassEditHelper.getInputTypeForColumn(oColumn)
+					};
+				});
+			},
+
+			getDefaultTextsForDialog: function(oResourceBundle, iSelectedContexts, oController) {
+				// 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.
+				var oView = oController.getView(),
+					bEditableTable = oView && oView.getModel("ui") && (oView.getModel("ui").getProperty("/editMode") === "Editable");
+
+				return {
+					"keepExistingPrefix": "< Keep",
+					"leaveBlankValue": "< Leave Blank >",
+					"clearFieldValue": "< Clear Values >",
+					"massEditTitle": oResourceBundle.getText("C_MASS_EDIT_DIALOG_TITLE", iSelectedContexts),
+					"applyButtonText": bEditableTable
+						? oResourceBundle.getText("C_MASS_EDIT_APPLY_BUTTON_TEXT")
+						: oResourceBundle.getText("C_MASS_EDIT_SAVE_BUTTON_TEXT"),
+					"cancelButtonText": oResourceBundle.getText("C_MASS_EDIT_CANCEL_BUTTON_TEXT")
+				};
+			},
+
+			/**
+			 * Adds a suffix to the 'keep existing' property of the comboBox.
+			 *
+			 * @param {string} sInputType InputType of the field
+			 * @returns {string}
+			 */
+			getSuffixForKeepExisiting: function(sInputType) {
+				var sResult = "Values";
+
+				switch (sInputType) {
+					//TODO - Add for other control types as well (Radio Button, Email, Input, MDC Fields, Image etc.)
+					case "sap.m.DatePicker":
+						sResult = "Dates";
+						break;
+					case "sap.m.CheckBox":
+						sResult = "Settings";
+						break;
+				}
+				return sResult;
+			},
+
+			/**
+			 * Adds default values to the model [Keep Existing Values, Leave Blank].
+			 * @param {Array} aValues Array instance where the default data needs to be added
+			 * @param {Array} aContexts Contexts for mass edit
+			 * @param {object} oDefaultValues Default values from Application Manifest
+			 * @param {object} oPropertyInfo Property information
+			 * @param {boolean} bUOMField
+			 */
+			setDefaultValuesToDialog: function(aValues, aContexts, oDefaultValues, oPropertyInfo, bUOMField) {
+				var sPropertyPath = oPropertyInfo.dataProperty,
+					sInputType = oPropertyInfo.inputType,
+					bPropertyRequired = oPropertyInfo.isFieldRequired;
+				var sSuffixForKeepExisting = MassEditHelper.getSuffixForKeepExisiting(sInputType);
+				//TODO - Add <<Use Value Help or control implmentation>> and related key by checking if value help is enabled for property or Unit.
+				//TODO - Add option Apply to Empty Fields only for Both Value Help and controls.
+				var bValueExistsForPropertyPath = aContexts.some(function(oSelectedContext) {
+					return oSelectedContext.getObject(sPropertyPath);
+				});
+				if (bValueExistsForPropertyPath) {
+					if (bPropertyRequired !== true && !bUOMField) {
+						aValues.unshift({ text: oDefaultValues.clearFieldValue, key: "ClearFieldValue/" + sPropertyPath });
+					}
+				} else {
+					aValues.unshift({ text: oDefaultValues.leaveBlankValue, key: "Empty/" + sPropertyPath });
+				}
+				aValues.unshift({
+					text: oDefaultValues.keepExistingPrefix + " " + sSuffixForKeepExisting + " >",
+					key: "Default/" + sPropertyPath
+				});
+			},
+
+			getTextArrangementInfo: function(sProperty, oTextBinding, sCurrentEntitySet, oSelectedContext) {
+				var oMetaModel = oSelectedContext.getModel().getMetaModel();
+				var sDisplayMode = CommonUtils.computeDisplayMode(oMetaModel.getObject(sCurrentEntitySet + "/" + sProperty + "@"));
+				var sDescriptionPath, sValue, sDescriptionValue, sFullText;
+				if (oTextBinding && (oTextBinding.path || (oTextBinding.parameters && oTextBinding.parameters.length)) && sProperty) {
+					if (oTextBinding.path) {
+						if (sDisplayMode === "Description") {
+							sValue = oSelectedContext.getObject(sProperty);
+							sDescriptionValue = oSelectedContext.getObject(oTextBinding.path);
+							sFullText = sDescriptionValue;
+						} else if (sDisplayMode === "Value") {
+							sValue = oSelectedContext.getObject(sProperty);
+							sFullText = sValue;
+						}
+					} else if (oTextBinding.parameters) {
+						oTextBinding.parameters.forEach(function(oProps) {
+							if (oProps.path && oProps.path !== sProperty) {
+								sDescriptionPath = oProps.path;
+							}
+						});
+						sValue = oSelectedContext.getObject(sProperty);
+						sDescriptionValue = oSelectedContext.getObject(sDescriptionPath);
+						if (sDisplayMode === "ValueDescription" && sValue && sDescriptionValue) {
+							sFullText = sValue + " (" + sDescriptionValue + ")";
+						} else if (sDisplayMode === "DescriptionValue" && sDescriptionValue && sValue) {
+							sFullText = sDescriptionValue + " (" + sValue + ")";
+						}
+					}
+					return {
+						"textArrangement": sDisplayMode,
+						"valuePath": sProperty,
+						"descriptionPath": sDescriptionPath,
+						"value": sValue,
+						"description": sDescriptionValue,
+						"fullText": sFullText
+					};
+				}
+				return false;
+			},
+
+			/**
+			 * 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 {Array} aContexts Contexts for mass edit
+			 * @param {Array} aDataArray Array containing data related to the dialog used by both the static and the runtime model
+			 * @param {object} oDefaultValues Default values from i18n
+			 * @returns {object}
+			 */
+			setRuntimeModelOnDialog: function(aContexts, aDataArray, oDefaultValues) {
+				var aValues = [],
+					aUnitData = [],
+					aResults = [],
+					aReadOnlyFieldInfo = [],
+					oDistinctValueMap = {},
+					sPropertyName;
+				aDataArray.forEach(function(oData) {
+					if (oData.dataProperty && oData.dataProperty.indexOf("/") > -1) {
+						var aFinalPath = MassEditHelper.initLastLevelOfPropertyPath(oData.dataProperty, aValues),
+							aPropertyPaths = oData.dataProperty.split("/"),
+							sPropertyKey;
+						for (var i = 0; i < aContexts.length; i++) {
+							var sMultiLevelPathValue = aContexts[i].getObject(oData.dataProperty);
+							sPropertyKey = oData.dataProperty + "/" + sMultiLevelPathValue;
+							if (!oDistinctValueMap[sPropertyKey] && aFinalPath[aPropertyPaths[aPropertyPaths.length - 1]]) {
+								var oTextInfo = MassEditHelper.getTextArrangementInfo(
+									oData.dataProperty,
+									oData.textBinding,
+									oData.entitySet,
+									aContexts[i]
+								);
+								aFinalPath[aPropertyPaths[aPropertyPaths.length - 1]].push({
+									"text": (oTextInfo && oTextInfo.fullText) || sMultiLevelPathValue,
+									"key": oData.dataProperty,
+									"textInfo": oTextInfo
+								});
+								oDistinctValueMap[sPropertyKey] = sMultiLevelPathValue;
+							}
+						}
+					} else {
+						aValues[oData.dataProperty] = aValues[oData.dataProperty] || [];
+						if (oData.unitProperty) {
+							aUnitData[oData.unitProperty] = aUnitData[oData.unitProperty] || [];
+						}
+						for (var i = 0; i < aContexts.length; i++) {
+							var oDataObject = aContexts[i].getObject();
+							sPropertyName = oData.dataProperty + "/" + oDataObject[oData.dataProperty];
+							if (oData.dataProperty && oDataObject[oData.dataProperty] && !oDistinctValueMap[sPropertyName]) {
+								var oTextInfo = MassEditHelper.getTextArrangementInfo(
+									oData.dataProperty,
+									oData.textBinding,
+									oData.entitySet,
+									aContexts[i]
+								);
+								aValues[oData.dataProperty].push({
+									"text": (oTextInfo && oTextInfo.fullText) || oDataObject[oData.dataProperty],
+									"key": oData.dataProperty,
+									"textInfo": oTextInfo
+								});
+								oDistinctValueMap[sPropertyName] = oDataObject[oData.dataProperty];
+							}
+							if (oData.unitProperty && oDataObject[oData.unitProperty]) {
+								sPropertyName = oData.unitProperty + "/" + oDataObject[oData.unitProperty];
+								if (!oDistinctValueMap[sPropertyName]) {
+									var oTextInfo = MassEditHelper.getTextArrangementInfo(
+										oData.unitProperty,
+										oData.textBinding,
+										oData.entitySet,
+										aContexts[i]
+									);
+									aUnitData[oData.unitProperty].push({
+										"text": (oTextInfo && oTextInfo.fullText) || oDataObject[oData.unitProperty],
+										"key": oData.unitProperty,
+										"textInfo": oTextInfo
+									});
+									oDistinctValueMap[sPropertyName] = oDataObject[oData.unitProperty];
+								}
+							}
+						}
+					}
+				});
+				aDataArray.forEach(function(oData) {
+					if (oData.dataProperty.indexOf("/") > -1) {
+						var sMultiLevelPropPathValue = MassEditHelper.getValueForMultiLevelPath(oData.dataProperty, aValues);
+						if (!sMultiLevelPropPathValue) {
+							sMultiLevelPropPathValue.push({ text: oDefaultValues.leaveBlankValue, key: "Empty/" + oData.dataProperty });
+						} else {
+							MassEditHelper.setDefaultValuesToDialog(sMultiLevelPropPathValue, aContexts, oDefaultValues, oData);
+						}
+					} else if (aValues[oData.dataProperty] && aValues[oData.dataProperty].length) {
+						MassEditHelper.setDefaultValuesToDialog(aValues[oData.dataProperty], aContexts, oDefaultValues, oData);
+					}
+					if (aUnitData[oData.unitProperty] && aUnitData[oData.unitProperty].length) {
+						MassEditHelper.setDefaultValuesToDialog(aUnitData[oData.unitProperty], aContexts, oDefaultValues, oData, true);
+					} else if (
+						(oData.dataProperty && aValues[oData.dataProperty] && !aValues[oData.dataProperty].length) ||
+						(oData.unitProperty && aUnitData[oData.unitProperty] && !aUnitData[oData.unitProperty].length)
+					) {
+						var bClearFieldOrBlankValueExists =
+							aValues[oData.dataProperty] &&
+							aValues[oData.dataProperty].some(function(obj) {
+								return obj.text === "< Clear Values >" || obj.text === "< Leave Blank >";
+							});
+						if (oData.dataProperty && !bClearFieldOrBlankValueExists) {
+							aValues[oData.dataProperty].push({ text: oDefaultValues.leaveBlankValue, key: "Empty/" + oData.dataProperty });
+						}
+						var bClearFieldOrBlankUnitValueExists =
+							aUnitData[oData.unitProperty] &&
+							aUnitData[oData.unitProperty].some(function(obj) {
+								return obj.text === "< Clear Values >" || obj.text === "< Leave Blank >";
+							});
+						if (oData.unitProperty && !bClearFieldOrBlankUnitValueExists) {
+							aUnitData[oData.unitProperty].push({
+								text: oDefaultValues.leaveBlankValue,
+								key: "Empty/" + oData.unitProperty
+							});
+						}
+					}
+					if (oData.isPropertyReadOnly && typeof oData.isPropertyReadOnly === "boolean") {
+						aReadOnlyFieldInfo.push({ "property": oData.dataProperty, value: oData.isPropertyReadOnly, type: "Default" });
+					} else if (oData.isPropertyReadOnly && oData.isPropertyReadOnly.operand1 && oData.isPropertyReadOnly.operand2) {
+						aReadOnlyFieldInfo.push({
+							"property": oData.dataProperty,
+							propertyPath: oData.isPropertyReadOnly.operand1.path,
+							propertyValue: oData.isPropertyReadOnly.operand2.value,
+							type: "Path"
+						});
+					}
+				});
+				var oData = { "values": aValues, "unitData": aUnitData, "results": aResults, "readablePropertyData": aReadOnlyFieldInfo };
+				var oDialogDataModel = new JSONModel(oData);
+				return oDialogDataModel;
+			},
+
+			/**
+			 * Create the mass edit dialog.
+			 * @param {object} oTable Instance of Table
+			 * @param {Array} aContexts Contexts for mass edit
+			 * @param {object} oController Controller for the view
+			 * @returns {object} Promise returning instance of dialog.
+			 */
+			createDialog: function(oTable, aContexts, oController) {
+				var sFragmentName = "sap/fe/core/controls/massEdit/MassEditDialog",
+					aDataArray = [],
+					oResourceBundle = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core"),
+					oDefaultValues = MassEditHelper.getDefaultTextsForDialog(oResourceBundle, aContexts.length, oController),
+					oExtensionAPI = oController && oController.getExtensionAPI(),
+					oDataFieldModel = MassEditHelper.prepareDataForDialog(oTable, aContexts, aDataArray),
+					oDialogDataModel = MassEditHelper.setRuntimeModelOnDialog(aContexts, aDataArray, oDefaultValues);
+
+				return new Promise(function(resolve, reject) {
+					var oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment");
+					return Promise.resolve(
+						XMLPreprocessor.process(
+							oFragment,
+							{ name: sFragmentName },
+							{
+								bindingContexts: {
+									dataFieldModel: oDataFieldModel.createBindingContext("/")
+								},
+								models: {
+									dataFieldModel: oDataFieldModel
+								}
+							}
+						)
+					)
+						.then(function(oFragment) {
+							return Fragment.load({ definition: oFragment }).then(function(oDialogContent) {
+								var oDialog = new Dialog({
+									title: oDefaultValues.massEditTitle,
+									content: [oDialogContent],
+									beginButton: {
+										text: oDefaultValues.applyButtonText,
+										type: "Emphasized",
+										press: function(oEvent) {
+											var oDialog = oEvent.getSource().getParent(),
+												oModel = oDialog.getModel("fieldsInfo"),
+												aResults = oModel.getProperty("/results"),
+												aPropertyReadableInfo = oModel.getProperty("/readablePropertyData"),
+												changePromise = [],
+												bReadOnlyField = false;
+
+											aContexts.forEach(function(oSelectedContext) {
+												aResults.forEach(function(oResult) {
+													//TODO - Add save implementation for Value Help.
+													if (aPropertyReadableInfo) {
+														bReadOnlyField = 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
+																	);
+																}
+															}
+														});
+													}
+													if (oResult.keyValue && oResult.value !== "Default" && !bReadOnlyField) {
+														changePromise.push(oSelectedContext.setProperty(oResult.keyValue, oResult.value));
+													}
+												});
+											});
+											return Promise.all(changePromise)
+												.then(function(oRes) {
+													var oListBinding = oTable.getRowBinding();
+													return oExtensionAPI.refresh(oListBinding.getPath()).then(function() {
+														oDialog.close();
+														oDialog.destroy();
+														return oRes;
+													});
+												})
+												.catch(function(oError) {
+													//TODO - Add error handling part for the Dialog
+													Log.error("Mass Edit: Something went wrong in updating entries.", oError);
+												});
+										}
+									},
+									endButton: {
+										text: oDefaultValues.cancelButtonText,
+										press: function(oEvent) {
+											var oDialog = oEvent.getSource().getParent();
+											oDialog.close();
+											oDialog.destroy();
+										}
+									}
+								});
+								oDialog.setModel(oDialogDataModel, "fieldsInfo");
+								resolve(oDialog);
+							});
+						})
+						.catch(reject);
+				});
+			}
+		};
+		return MassEditHelper;
+	}
+);