@sap/open.fe 1.99.0 → 1.100.0

package/packages/sap.fe.core/src/sap/fe/core/helpers/MassEditHelper.ts

@@ -0,0 +1,699 @@
+import Dialog from "sap/m/Dialog";
+import XMLTemplateProcessor from "sap/ui/core/XMLTemplateProcessor";
+import JSONModel from "sap/ui/model/json/JSONModel";
+import Fragment from "sap/ui/core/Fragment";
+import XMLPreprocessor from "sap/ui/core/util/XMLPreprocessor";
+import Log from "sap/base/Log";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import Table from "sap/ui/mdc/Table";
+import ResourceBundle from "sap/base/i18n/ResourceBundle";
+import Button from "sap/m/Button";
+import PageController from "sap/fe/core/PageController";
+import { convertMetaModelContext, getInvolvedDataModelObjects } from "../converters/MetaModelConverter";
+import { getTextBinding } from "sap/fe/macros/field/FieldTemplating";
+import { getEditableExpression, getRequiredExpression } from "../templating/UIFormatters";
+import { isReadOnlyExpression } from "../templating/FieldControlHelper";
+import { hasValueHelpWithFixedValues } from "sap/fe/core/templating/PropertyHelper";
+
+/* This class contains helpers to be used for mass edit functionality */
+type TextArrangementInfo = {
+	textArrangement: string;
+	valuePath: string;
+	descriptionPath?: string;
+	value: string;
+	description: string;
+	fullText: string;
+};
+const aValidDataTypes = [
+	"Edm.Boolean",
+	"Edm.Byte",
+	"Edm.Decimal",
+	"Edm.Double",
+	"Edm.Float",
+	"Edm.Guid",
+	"Edm.Int16",
+	"Edm.Int32",
+	"Edm.Int64",
+	"Edm.SByte",
+	"Edm.Single",
+	"Edm.String"
+];
+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 {string} sPath Property path
+	 * @param {Array} aValues Array instance where the default data needs to be added
+	 * @returns {Array}
+	 */
+	initLastLevelOfPropertyPath: function(sPath: string, aValues: any) {
+		let aFinalPath: any;
+		let index = 0;
+		const aPaths = sPath.split("/");
+		let sFullPath = "";
+		aPaths.forEach(function(sPropertyPath: string) {
+			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: string, index: number, self: any[]) {
+		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: string, oValues: any) {
+		if (sDataPropertyPath && sDataPropertyPath.indexOf("/") > 0) {
+			const aPropertyPaths = sDataPropertyPath.split("/");
+			let Result: any;
+			aPropertyPaths.forEach(function(sPath: string) {
+				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: any[], sDataPropertyPath: string) {
+		if (sDataPropertyPath && aContexts.length > 0) {
+			const oSelectedContext = aContexts,
+				aPropertyValues: any[] = [];
+			oSelectedContext.forEach(function(oContext: any) {
+				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) {
+				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: any, aContexts: any[]) {
+		if (hiddenValue && hiddenValue.$Path) {
+			return !aContexts.some(function(oSelectedContext: any) {
+				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: Table, aContexts: any[], aDataArray: any[]) {
+		const oMetaModel = oTable && (oTable.getModel().getMetaModel() as any),
+			sCurrentEntitySetName = oTable.data("metaPath"),
+			aTableFields = MassEditHelper.getTableFields(oTable),
+			oEntityTypeContext = oMetaModel.getContext(sCurrentEntitySetName + "/@"),
+			oDataModelObjectPath = getInvolvedDataModelObjects(oEntityTypeContext);
+
+		const oDataFieldModel = new JSONModel();
+		let oResult;
+		let sLabelText;
+		let bValueHelpEnabled;
+		let sUnitPropertyPath;
+		let bValueHelpEnabledForUnit;
+		let bIsImmutable;
+		let bIsComputed;
+		let bChartProperty;
+		let oTextBinding;
+		let bValidDataType;
+		let bInValidInputType;
+
+		aTableFields.forEach(function(oColumnInfo: any) {
+			const sDataPropertyPath = oColumnInfo.dataProperty;
+			if (sDataPropertyPath) {
+				let 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: any
+					) {
+						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();
+				bIsImmutable =
+					oPropertyContext && oPropertyContext.getProperty() && oPropertyContext.getProperty()["@Org.OData.Core.V1.Immutable"];
+				bIsComputed =
+					oPropertyContext && oPropertyContext.getProperty() && oPropertyContext.getProperty()["@Org.OData.Core.V1.Computed"];
+				const 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;
+					}
+				};
+				oPropertyInfo =
+					(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 isReadOnly = isReadOnlyExpression(oPropertyInfo);
+				bChartProperty = oPropertyInfo && oPropertyInfo.term && oPropertyInfo.term === "com.sap.vocabularies.UI.v1.Chart";
+				bValidDataType = oPropertyInfo && aValidDataTypes.indexOf(oPropertyInfo.type) !== -1;
+				bInValidInputType =
+					(oColumnInfo &&
+						oColumnInfo.inputType &&
+						(oColumnInfo.inputType === "sap.m.RatingIndicator" || oColumnInfo.inputType === "sap.ui.mdc.MultiValueField")) ||
+					hasValueHelpWithFixedValues(oPropertyInfo);
+				if (
+					sDataPropertyPath &&
+					!bHiddenField &&
+					!bIsImmutable &&
+					!bIsComputed &&
+					!bChartProperty &&
+					bValidDataType &&
+					!bInValidInputType &&
+					oColumnInfo.inputType &&
+					getEditableExpression(oPropertyInfo, oDataFieldConverted, oDataModelObjectPath) !== "false"
+				) {
+					oResult = {
+						"label": sLabelText + ":",
+						"visible":
+							sDataPropertyPath &&
+							!bHiddenField &&
+							!bIsImmutable &&
+							!bIsComputed &&
+							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": getRequiredExpression(oPropertyInfo, oDataFieldConverted, true),
+						"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": isReadOnly !== undefined ? isReadOnly : false
+					};
+					aDataArray.push(oResult);
+				}
+			}
+		});
+		oDataFieldModel.setData(aDataArray);
+		return oDataFieldModel;
+	},
+
+	getInputTypeForColumn: function(oColumn: any) {
+		return (
+			oColumn.getTemplate().getContent &&
+			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: any) {
+		const aColumns = (oTable && oTable.getColumns()) || [];
+		return aColumns.map(function(oColumn: any) {
+			const sDataProperty = oColumn && oColumn.getDataProperty(),
+				aRealtedColumnInfo =
+					oTable.data("columns") &&
+					oTable.data("columns").customData.filter(function(oColumnInfo: any) {
+						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: any, iSelectedContexts: any, oTable: any) {
+		// 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"),
+			"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: string) {
+		let 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: any[], aContexts: any[], oDefaultValues: any, oPropertyInfo: any, bUOMField?: boolean) {
+		const sPropertyPath = oPropertyInfo.dataProperty,
+			sInputType = oPropertyInfo.inputType,
+			bPropertyRequired = oPropertyInfo.isFieldRequired;
+		const 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.
+		const bValueExistsForPropertyPath = aContexts.some(function(oSelectedContext: any) {
+			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: any,
+		oTextBinding: any,
+		sCurrentEntitySet: any,
+		oSelectedContext: any
+	): TextArrangementInfo | undefined {
+		const oMetaModel = oSelectedContext.getModel().getMetaModel();
+		const sDisplayMode = CommonUtils.computeDisplayMode(oMetaModel.getObject(sCurrentEntitySet + "/" + sProperty + "@"));
+		let 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: any) {
+					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 undefined;
+	},
+
+	/**
+	 * 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: any[], aDataArray: any[], oDefaultValues: any) {
+		const aValues: any[] = [];
+		const aUnitData: any[] = [];
+		const aResults: any[] = [];
+		const aReadOnlyFieldInfo: any[] = [];
+		const oDistinctValueMap: any = {};
+		let sPropertyName;
+		aDataArray.forEach(function(oData: any) {
+			let oTextInfo;
+			if (oData.dataProperty && oData.dataProperty.indexOf("/") > -1) {
+				const aFinalPath = MassEditHelper.initLastLevelOfPropertyPath(oData.dataProperty, aValues);
+				const aPropertyPaths = oData.dataProperty.split("/");
+				let sPropertyKey;
+				for (let i = 0; i < aContexts.length; i++) {
+					const sMultiLevelPathValue = aContexts[i].getObject(oData.dataProperty);
+					sPropertyKey = oData.dataProperty + "/" + sMultiLevelPathValue;
+					if (!oDistinctValueMap[sPropertyKey] && aFinalPath[aPropertyPaths[aPropertyPaths.length - 1]]) {
+						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 (let i = 0; i < aContexts.length; i++) {
+					const oDataObject = aContexts[i].getObject();
+					sPropertyName = oData.dataProperty + "/" + oDataObject[oData.dataProperty];
+					if (oData.dataProperty && oDataObject[oData.dataProperty] && !oDistinctValueMap[sPropertyName]) {
+						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]) {
+							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: any) {
+			if (oData.dataProperty.indexOf("/") > -1) {
+				const 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)
+			) {
+				const bClearFieldOrBlankValueExists =
+					aValues[oData.dataProperty] &&
+					aValues[oData.dataProperty].some(function(obj: any) {
+						return obj.text === "< Clear Values >" || obj.text === "< Leave Blank >";
+					});
+				if (oData.dataProperty && !bClearFieldOrBlankValueExists) {
+					aValues[oData.dataProperty].push({ text: oDefaultValues.leaveBlankValue, key: "Empty/" + oData.dataProperty });
+				}
+				const bClearFieldOrBlankUnitValueExists =
+					aUnitData[oData.unitProperty] &&
+					aUnitData[oData.unitProperty].some(function(obj: any) {
+						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.operands &&
+				oData.isPropertyReadOnly.operands[0] &&
+				oData.isPropertyReadOnly.operands[0].operand1 &&
+				oData.isPropertyReadOnly.operands[0].operand2
+			) {
+				// This needs to be refactored in accordance with the ReadOnlyExpression change
+				aReadOnlyFieldInfo.push({
+					"property": oData.dataProperty,
+					propertyPath: oData.isPropertyReadOnly.operands[0].operand1.path,
+					propertyValue: oData.isPropertyReadOnly.operands[0].operand2.value,
+					type: "Path"
+				});
+			}
+		});
+		const oData = { "values": aValues, "unitData": aUnitData, "results": aResults, "readablePropertyData": aReadOnlyFieldInfo };
+		const 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: Table, aContexts: any[], oController: PageController) {
+		const sFragmentName = "sap/fe/core/controls/massEdit/MassEditDialog",
+			aDataArray: any[] = [],
+			oResourceBundle = sap.ui.getCore().getLibraryResourceBundle("sap.fe.core") as ResourceBundle,
+			oDefaultValues = MassEditHelper.getDefaultTextsForDialog(oResourceBundle, aContexts.length, oTable),
+			oDataFieldModel = MassEditHelper.prepareDataForDialog(oTable, aContexts, aDataArray),
+			oDialogDataModel = MassEditHelper.setRuntimeModelOnDialog(aContexts, aDataArray, oDefaultValues);
+
+		return new Promise(function(resolve: (value: any) => void, reject: (reason?: any) => void) {
+			const oFragment = XMLTemplateProcessor.loadTemplate(sFragmentName, "fragment");
+			return Promise.resolve(
+				XMLPreprocessor.process(
+					oFragment,
+					{ name: sFragmentName },
+					{
+						bindingContexts: {
+							dataFieldModel: oDataFieldModel.createBindingContext("/")
+						},
+						models: {
+							dataFieldModel: oDataFieldModel
+						}
+					}
+				)
+			)
+				.then(function(oFragment: any) {
+					return Fragment.load({ definition: oFragment }).then(function(oDialogContent: any) {
+						const oDialog = new Dialog({
+							title: oDefaultValues.massEditTitle,
+							content: [oDialogContent],
+							beginButton: new Button({
+								text: oDefaultValues.applyButtonText,
+								type: "Emphasized",
+								press: function(oEvent: any) {
+									const oDialog = oEvent.getSource().getParent();
+									const oModel = oDialog.getModel("fieldsInfo");
+									const aResults = oModel.getProperty("/results");
+									const aPropertyReadableInfo = oModel.getProperty("/readablePropertyData");
+									const changePromise: any[] = [];
+									let bReadOnlyField = false;
+
+									aContexts.forEach(function(oSelectedContext: any) {
+										aResults.forEach(function(oResult: any) {
+											//TODO - Add save implementation for Value Help.
+											if (aPropertyReadableInfo) {
+												bReadOnlyField = aPropertyReadableInfo.some(function(oPropertyInfo: any) {
+													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: any[]) {
+											const oListBinding = oTable.getRowBinding(),
+												oExtensionAPI = oController && (oController.getExtensionAPI() as any);
+											return oExtensionAPI.refresh(oListBinding.getPath()).then(function() {
+												oDialog.close();
+												oDialog.destroy();
+												return oRes;
+											});
+										})
+										.catch(function(oError: any) {
+											//TODO - Add error handling part for the Dialog
+											Log.error("Mass Edit: Something went wrong in updating entries.", oError);
+										});
+								}
+							}),
+							endButton: new Button({
+								text: oDefaultValues.cancelButtonText,
+								press: function(oEvent: any) {
+									const oDialog = oEvent.getSource().getParent();
+									oDialog.close();
+									oDialog.destroy();
+								}
+							})
+						});
+						oDialog.setModel(oDialogDataModel, "fieldsInfo");
+						resolve(oDialog);
+					});
+				})
+				.catch(reject);
+		});
+	}
+};
+
+export default MassEditHelper;